MOSAID Articles & Tutorials - Linux

KolourPaint: The MS Paint Replacement I Finally Found After 20 Years of Linux

2026-06-29T13:29:16+00:00

I’ve been using Linux as my daily driver for almost 20 years, and I haven’t touched Windows for over 15. Despite that, one tiny thing kept nagging me: the absence of a truly simple, drop‑in replacement for Microsoft Paint. When you need to crop a screenshot, add an arrow, or scribble a quick annotation, you don’t want to launch a behemoth like GIMP. You want something that opens instantly, lets you make the edit, and gets out of your way.

For years I tried to fill the void. GIMP is an amazing piece of software, but it’s a sledgehammer when all you need is a thumbtack. Pinta came close, but it always felt a little “off” – minor UI glitches and a dependency stack that sometimes broke. MyPaint, drawing tablets, raw pixel editors – none of them replicated the immediacy of MS Paint. Then, by accident, I stumbled across KolourPaint.

Discovery and First Impressions

I was scanning a forum thread about lightweight KDE applications when someone mentioned KolourPaint. I installed it with zero expectations and found myself grinning within 30 seconds. The layout, the tool palette, the default behaviour – it was as if MS Paint had been ported natively to Linux, with subtle improvements. No bloated menus, no confusing layer system, just a canvas and a set of tools that work exactly how you remember.

KolourPaint is part of the KDE ecosystem, but it runs perfectly on any desktop environment. It respects the Unix philosophy: do one thing (simple image editing) and do it well. The startup time is virtually instant, the memory footprint is negligible, and it integrates with your file manager as you’d expect.

Feature Comparison: MS Paint vs. KolourPaint

Feature	MS Paint (Classic)	KolourPaint
Startup speed	Instant	Instant
Basic drawing tools	Yes	Yes, with additional shapes
Text tool	Limited	Rich text support, antialiasing
Transparency handling	No	Yes (alpha channel)
Colour palette	Fixed	Configurable, with colour picker
Format support	BMP, PNG, JPEG, GIF	BMP, PNG, JPEG, GIF, TIFF, ICO, WebP, and more
Undo/Redo	Limited	Unlimited history
Keyboard shortcuts	Basic	Extensive, customisable

The feature set is familiar enough to be comfortable, yet modern enough to handle real-world tasks. I never have to think about “how do I do X?” because the answer is always the same as it was in MS Paint – it just works.

Daily Workflow Integration

As a developer and technical writer, I constantly manipulate screenshots. A typical flow looks like this:

•Capture: Use Spectacle (or scrot) to grab a region.

•Annotate: Open the screenshot directly in KolourPaint with one click.

•Add: Arrows, rectangles, text, or highlights using the toolbox.

•Export: Save as optimised PNG and drop into my documentation.

This entire pipeline takes less than 30 seconds because KolourPaint introduces zero friction. The ability to set a default save format (I always use PNG) means I never see a format dialog. The colour picker remembers my last used colours, so consistent branding is trivial.

Why Lightweight Tools Matter

Power users often build complex toolchains, but the weak link is almost always the “tiny edit” step. When a simple crop or annotation requires opening a 500 MB application, you’re pulled out of your flow. Over a day, those context switches add up to hours of lost productivity. KolourPaint solves this by being intentionally minimal.

It doesn’t try to be a photo editor, a painting simulator, or a design suite. It’s a straight‑to‑the‑point editing surface for raster images. That focus is exactly why it succeeds where GIMP, Pinta, and others fail for quick tasks.

Installation

KolourPaint is available in the repositories of virtually every major distribution. Installing it is a single command:


sudo apt install kolourpaint        # Debian / Ubuntu / Mint
sudo dnf install kolourpaint        # Fedora / RHEL
sudo pacman -S kolourpaint          # Arch Linux / Manjaro

No additional configuration is required. Once installed, it appears in your application launcher and can be associated with all common image formats.

Tradeoffs

No tool is perfect. KolourPaint’s strength—its simplicity—is also its limitation. It won’t replace advanced editors for compositing, colour grading, or professional graphic design. If you need non‑destructive layers or CMYK colour space, look elsewhere. But for the 90 % of edits that consist of cropping, resizing, simple drawing, and annotation, it’s ideal.

Another tradeoff: it’s a KDE application, so it pulls in several KDE libraries if you’re on a pure GTK‑based system. The footprint is still negligible by modern standards, but worth knowing.

Final Thoughts

After two decades, I finally have the one tool that makes me forget MS Paint ever existed. KolourPaint respects my time, my muscle memory, and my workflow. It’s a testament to the fact that sometimes the best software isn’t the most feature‑rich; it’s the one that disappears and lets you do your work.

If you’ve ever missed the simplicity of MS Paint on Linux, do yourself a favour and install KolourPaint. You’ll wonder why you didn’t find it sooner.

5 Ultra-Light Linux Distributions for 256 MB – 1 GB RAM Machines as a Child’s First Engineering Workstation

2026-06-21T15:08:50+00:00

Why Give a Child a Computer That “Can’t Do Anything”

Most parents face the same dilemma: a smartphone or tablet appears to be the easy gift—it keeps children occupied, it is “educational,” and it requires zero effort. But the device is also a slot machine. Every notification, every autoplaying video, every “like” is engineered to hold attention hostage. We are not giving them tools; we are handing them carefully optimised compulsion engines.

An old laptop running a deliberately lightweight Linux distribution is the exact opposite: it is a sandbox where curiosity, not compulsion, drives the interaction.

This article is not a nostalgic plea. It is an engineering walkthrough for parents (and mentors) who want to repurpose hardware with 256 MB, 512 MB, or 1 GB of RAM into a deterministic, offline-first learning workstation. We will examine five Linux distributions that treat scarce resources as a feature, not a bug, and discuss how each one can become the first real computer of a future developer.

The Hardware Landscape: Why 256 MB Still Matters

Many households have a forgotten netbook, a Pentium 4 desktop, or a single-board computer that was discarded because Windows XP or 7 became unusable. In engineering terms, these machines are not dead—they are thermally quiet, mechanically simple, and perfectly capable of running a fully-fledged POSIX environment if we shed the weight of modern graphical stacks.

•256 MB RAM: The absolute floor. A kernel, a window manager, a terminal, and a small editor can coexist. The experience is entirely text-centric, which is an asset for learning.

•512 MB RAM: Comfortable for a lightweight desktop, a browser like NetSurf or Dillo for offline documentation, and an interpreted language environment (Python, Lua, or Guile).

•1 GB RAM: Enough to run a modern-ish browser with careful tab management, a full IDE like Geany, and a GCC toolchain without swapping to death.

Scarcity enforces good engineering habits: no resource is wasted, no daemon runs without justification, and every megabyte is accounted for.

Selection Criteria

We judged distributions by the following engineering requirements:

•Base memory footprint: Must idle below 128 MB (ideally below 64 MB) after boot, leaving room for applications.

•Deterministic behaviour: No auto‑started services that silently consume cycles; reproducible builds are preferred.

•Offline capability: Full local package repositories or single‑file installers that do not demand constant internet access.

•Child‑safe toolchain: Easy to lock down (no app store, no advertising), with simple access to programming languages and build tools.

•Community longevity: Not a one‑person hobby project likely to vanish in six months.

The five distributions below satisfy these constraints and represent different philosophies in minimalism.

1. Alpine Linux – The Purpose‑Built Base

Alpine is a security‑oriented distribution built around musl libc, BusyBox, and OpenRC. It is designed for containers and embedded systems, but a desktop mode is trivially constructed from its package repository. A base Alpine installation can boot into a console using less than 40 MB of RAM.

•Memory model: No systemd, no dbus, no polkit by default. Every service is explicitly enabled. Adding a lightweight Wayland compositor like sway or a stacking window manager like i3 yields a graphical environment that idles around 100 MB.

•Package management: APK is fast, transactional, and works entirely from local cache. You can mirror the repository on a USB stick.

•For a child: Alpine teaches the anatomy of a Linux system. The child learns about runlevels, init scripts, and manual network configuration. Install python3, gcc, and geany to create a minimal development desktop.



# After base Alpine install:
setup-xorg-base
apk add i3wm i3status dmenu rxvt-unicode
apk add python3 py3-pip gcc musl-dev make
apk add geany
# Start X and i3 manually – no display manager bloat

2. Puppy Linux – The Portable Workshop

Puppy Linux is not a single distribution but a family of extremely compact live images that load entirely into RAM. Its core design principle—run from RAM, save sessions only on demand—makes it ideal for very old hardware and for children who might accidentally corrupt a persistent install.

•Memory footprint: The official Fossapup64 9.5 runs comfortably in 512 MB of RAM, with reports of success on 256 MB using zram swap. The “pfix=ram” boot parameter prevents touching the hard disk at all.

•Persistence model: Sessions are saved into a single .sfs file or a dedicated save folder. Corruption is trivial to revert.

•Child‑friendliness: Puppy comes with a curated set of lightweight applications (AbiWord, Gnumeric, mtPaint) and a simple menu. The JWM window manager is fast and unintimidating. Adding devx.sfs gives a full GCC toolchain.

3. Tiny Core Linux – The LEGO Brick of Operating Systems

Tiny Core Linux (TCL) is the smallest desktop distribution in active maintenance. Its “Core” ISO is 17 MB; the “CorePlus” image with a graphical environment is around 160 MB. TCL treats the operating system as a collection of interchangeable extensions, much like a set of precise engineering components.

•Architecture: The kernel and a minuscule root filesystem load into RAM. Everything else—window managers, editors, compilers—are extensions (.tcz files) mounted on demand. This means a 256 MB machine can boot a full GUI with networking and still have free RAM for user applications.

•Learning value: Every component is explicit. The child will see exactly what a window manager is because they install flwm_topside.tcz themselves. This demystifies the “magic” of a modern OS.

•Toolchain: The compiletc.tcz meta‑extension pulls in GCC, make, headers, and libraries. Python, Lua, and Tcl are available as single extensions.



# Boot TinyCore, then:
tce-load -wi Xvesa flwm_topside aterm wbar
tce-load -wi compiletc
tce-load -wi python3.11
# Start the desktop with 'startx'

4. antiX – The “Just Works” Lightweight Legacy

antiX is a Debian‑based distribution that explicitly targets 256 MB RAM systems. It ships with a choice of lightweight window managers—IceWM (default), Fluxbox, and JWM—and replaces systemd with runit or sysvinit. antiX is the closest thing to a turn‑key Debian desktop that respects a 256 MB budget.

•Memory: Full‑featured IceWM desktop idles around 80 MB on a fresh boot. The antiX-base ISO strips even more, ideal for custom setups.

•Package ecosystem: Being Debian‑compatible means access to apt and tens of thousands of packages, but we must be selective. Avoid heavyweight default recommends (--no-install-recommends) to keep the footprint low.

•For the child: Install geany, python3, idle3, and optionally scratch (visual programming). The traditional desktop metaphor is immediately understandable, yet the system encourages exploration under the hood.

5. SliTaz – The Small‑Footprint Powerhouse

SliTaz is a French‑origin rolling‑release distribution that delivers a fully‑featured Openbox desktop inside a 50 MB ISO. Its package manager, tazpkg, handles dependencies cleverly and supports converting packages from other distros. SliTaz proves that a complete, fast desktop does not need even 256 MB of RAM—it thrives on 128 MB.

•Design philosophy: The system uses a hybrid init (BusyBox + custom scripts), a hand‑crafted control panel, and a collection of home‑grown tools that feel remarkably cohesive. The live session runs from RAM and can be installed in minutes.

•Development environment: The slitaz-toolchain package provides GCC. Python, Ruby, and Lua are one command away. The built‑in web server (BusyBox httpd) lets a child share a local page instantly—a gateway to web development without the internet.

•Caveat: The community is smaller, and hardware support on extremely new machines can be patchy, but on old hardware it excels.

Turning an Old Laptop into a “First Computer” Gift

All five distributions share a critical property for a child’s learning environment: they are quiet. They do not ping notifications, they do not autoplay videos, they do not recommend “content.” When a child opens the terminal, it stays open. When they write code, it waits for them. This friction‑free, distraction‑free state is precisely the opposite of a smartphone experience.

Practical steps for a parent or mentor:

•Choose the hardware: A 2008–2012 laptop with at least 512 MB RAM, a functioning keyboard, and a working display. Replace the spinning disk with a cheap CompactFlash‑to‑IDE or SD‑to‑SATA adapter for silent operation and reliability.

•Install the distribution of choice: Use the minimal instructions above. Do not set up Wi‑Fi unless you intend to supervise—offline is safer and faster.

•Preload learning materials: Place offline documentation (devdocs.io offline bundle, the Python tutorial, a copy of “The Linux Command Line”) directly in /home/child/Documents.

•Create a short, printed “starter card” showing how to open the terminal, launch the editor, and run a simple Python script. This transforms the machine from an intimidating blank screen into a known‑good playground.

•Set a challenge, not a lesson: “Make the computer print your name one hundred times.” “Draw a square with turtle.” “Write a guessing game.” Problems drive learning; instructions alone do not.

Performance Considerations and Tuning

On sub‑1 GB systems, every service matters. Apply these tweaks regardless of distribution:

•Use zram instead of disk swap. A 128 MB zram device compresses to roughly 40–50 MB, effectively expanding usable RAM without touching slow storage.

•Prefer static linking or minimal shared libraries. Musl‑based systems (Alpine) naturally avoid glibc bloat. On Debian‑based distros, avoid installing unnecessary -dev packages until needed.

•Replace heavy browsers. NetSurf, Dillo, or even w3m for local HTML docs. Do not install Firefox or Chromium on a machine with less than 1 GB—they will swap the system into unusability.

•Monitor with htop or btm. Show the child what RAM and CPU look like. Make resource monitoring part of the learning ritual.

The Long‑Term Payoff: Raising Engineers Instead of Consumers

A child who grows up on a minimal Linux machine learns that computers are not magic; they are mechanisms.

When a program crashes, they will not stare at a spinner—they will open dmesg. When they need a new tool, they will not tap “Install”—they will compile it and learn about dependencies. These are the reflex habits of an engineer. The smartphone generation has been robbed of this; our job is to give it back.

There is no guarantee that every child will become a programmer, but a deterministic, offline, open‑source machine teaches something far more valuable: the confidence that they can understand and control the systems around them. That confidence transfers to any technical field—and it begins with a 256 MB laptop and a blinking cursor.

Tradeoffs and When This Approach Does Not Fit

We must be honest. These distributions are not substitutes for a modern desktop. Video editing, heavy web applications, and modern gaming are impossible. If the child requires a web browser for school‑mandated online platforms, a 1 GB machine with a minimal Chromium may just suffice, but expect slow performance. The goal is not to replace a mainstream PC; it is to provide a first‑principles computing experience that intentionally excludes the distracting parts of the internet.

Also, parental involvement remains necessary. A bare Linux command line can be intimidating; the “starter card” and some pair‑programming sessions make the difference between a cherished tool and a paperweight.

Final Thoughts

The five distributions surveyed—Alpine, Puppy, Tiny Core, antiX, and SliTaz—each take a different path to the same destination: a functional, responsive, and deeply educational environment on hardware the world has abandoned. They are not toys; they are precision instruments for teaching computation from the metal up.

The most valuable gift you can give a curious child is not a device designed to extract their attention, but a machine that rewards it.

Repurpose an old laptop. Install one of these distributions. Hand it over with a printed Python cheat sheet and a challenge. You might be surprised how fast they outgrow the hardware—and how soon they start asking for a more powerful machine, not to play games, but to run bigger simulations.

5 Reasons Most People Stick With Windows Even Though Linux Is Free

2026-06-05T21:38:30+00:00

The Linux Paradox

Every few years the same question resurfaces somewhere on the Internet: if Linux is free, open source, highly customizable, and capable of powering everything from smartphones to supercomputers, why do most people still use Windows? The question sounds straightforward, but it contains a hidden assumption that has distorted the discussion for decades. It assumes operating systems compete primarily through technical merit. Engineers tend to think this way because engineers spend their lives comparing architectures, evaluating tradeoffs, measuring performance, and optimizing systems. The desktop market, however, has never been governed solely by engineering considerations. It is governed by institutions, habits, incentives, compatibility requirements, training pipelines, and economic forces — many of them deliberately engineered by Microsoft itself.

Viewed purely as an engineering artifact, Linux is an extraordinary achievement. A collaborative development model involving thousands of contributors has produced an operating system that dominates cloud infrastructure, powers most of the Internet, runs the overwhelming majority of supercomputers, forms the foundation of Android, and serves as the backbone of modern containerized workloads. Entire industries depend on Linux. Most people interact with Linux-powered systems dozens or hundreds of times every day without realizing it. The irony is that Linux won many of the most important battles in computing while simultaneously remaining a minority platform on personal desktops — a direct result of aggressive, decades-long market manipulation.

This apparent contradiction becomes easier to understand once we stop thinking about operating systems as software products and start thinking about them as ecosystems. A desktop operating system is not merely a kernel, a graphical interface, and a collection of utilities. It is an ecosystem composed of software vendors, hardware manufacturers, educational institutions, certification programs, government procurement policies, support organizations, training materials, and millions of users whose workflows evolve around a common set of assumptions. Once an ecosystem reaches sufficient scale, its momentum becomes one of its most valuable assets — and Microsoft understood this earlier than anyone else. At that point, the platform is no longer succeeding because of its technical characteristics alone. It succeeds because every participant reinforces the decisions made by every other participant, often in ways that were anything but accidental.

Desktop Computing Is Not a Technical Market

One of the recurring mistakes Linux enthusiasts make is assuming that most computer users evaluate operating systems the same way engineers do. They imagine a consumer comparing filesystems, package managers, security models, kernel architectures, and resource utilization before selecting the objectively superior platform. In reality, the overwhelming majority of users rarely think about operating systems at all. They think about applications. A graphic designer cares about the availability of design tools. An accountant cares about spreadsheet compatibility. A business owner cares about whether documents can be exchanged seamlessly with clients. A student cares about using the same software required by teachers and classmates. The operating system is simply the environment in which these activities occur.

This distinction is critical because it explains why software ecosystems tend to dominate technical discussions. From a user's perspective, the value of an operating system is often proportional to the applications available on it. Windows spent decades accumulating commercial software vendors, enterprise customers, educational partnerships, hardware certifications, and developer mindshare — often through practices that were later ruled anticompetitive. Every new participant increased the value of the ecosystem for everyone else. Software vendors targeted Windows because customers used Windows. Customers used Windows because software vendors targeted Windows. Hardware manufacturers optimized for Windows because that is where demand existed. Demand increased because hardware compatibility was strongest on Windows. The resulting feedback loop became self-reinforcing long before Linux desktop distributions matured into their current state.

This phenomenon is not unique to operating systems. Similar dynamics appear throughout technology. The most widely adopted solution is not always the most elegant solution. Sometimes it is simply the solution that accumulated enough momentum early enough — and wielded enough market power ruthlessly enough — to become the default choice for everyone who arrived later.

The Power of Defaults

Perhaps the single greatest advantage Windows possesses has nothing to do with engineering. It is distribution. Most users never consciously choose Windows. The decision is made for them long before they unbox their first computer. A laptop arrives with Windows preinstalled, configured, documented, and supported. The user powers it on, creates an account, and immediately begins associating that environment with the concept of personal computing itself. There is no operating system selection process. There is no comparison. There is no migration decision. There is only the continuation of the default path — a path paved with exclusive OEM agreements that Microsoft fought viciously to maintain.

Engineers often underestimate how powerful default choices are because they spend much of their careers deliberately evaluating alternatives. Most people do not. Human beings are remarkably efficient at preserving familiarity. Once a workflow functions adequately, the incentive to replace it diminishes dramatically. A user who has spent ten years learning keyboard shortcuts, application behavior, troubleshooting techniques, and file management habits within one ecosystem will naturally perceive switching costs even when the alternative is objectively attractive. The technical superiority of a replacement matters far less than the practical inconvenience of abandoning accumulated experience — an inconvenience Microsoft has profited from for decades.

This principle scales beyond individuals. Entire organizations exhibit the same behavior. Once procedures, documentation, training materials, and support workflows are built around a platform, changing that platform becomes increasingly difficult. The operating system becomes embedded within the organization's institutional memory, locking in the status quo with a grip that even a zero-cost alternative struggles to break.

How Governments Were Bought to Embed Windows in Education

One of the most underappreciated — and ethically troubling — contributors to Windows dominance is the direct role Microsoft played in purchasing influence within educational systems. Across much of the world, students encounter Microsoft products long before they possess enough technical knowledge to understand what an operating system is. Computer laboratories are standardized around Windows not by accident but through deliberate government procurement agreements that Microsoft lobbied for aggressively. Office productivity courses are built around Microsoft Office because educational ministries signed multi-year licensing deals that made alternatives invisible. Training materials assume Windows screenshots, Windows terminology, and Windows workflows, conditioning an entire generation before they could form their own technical preferences.

This process did not emerge from free market competition. It was engineered. Microsoft invested enormous resources in government relations, offering discounted or even free software licenses to ministries of education, local authorities, and public schools. These were not charitable donations; they were calculated investments designed to turn entire national education systems into Microsoft training pipelines. Students who learn computing exclusively through Microsoft products are unlikely to question those products later. By the time they reach adulthood, years of exposure have normalized a single vendor ecosystem as the default model of computing — a model that just happens to require a paid license for the operating system and core productivity tools.

The result is a taxpayer-funded indoctrination program that masquerades as education. Governments, often under intense lobbying pressure and the promise of short-term cost savings, lock themselves into proprietary ecosystems that then become nearly impossible to escape. Schools teach technologies that employers expect, but employers expect those technologies precisely because schools have taught nothing else for two decades. The cycle continuously reinforces itself, and Microsoft sits at the center, extracting rents from a captive market it helped create.

Computer science students sometimes escape this conditioning. They encounter Linux while studying operating systems, networking, distributed systems, cloud infrastructure, security, embedded systems, or software engineering. Yet even here an interesting paradox emerges. Many graduates become comfortable administering Linux servers while continuing to use Windows on their desktops — a testament to how thoroughly the educational pipeline has divorced tool choice from technical merit.

Why Linux Won the Server but Not the Desktop

The history of Linux demonstrates an important lesson about technology adoption. Systems succeed when their strengths align with the incentives of the environments in which they operate. Linux became dominant in servers because server administrators value characteristics that Linux provides exceptionally well. Automation, remote administration, transparency, scriptability, reproducibility, composability, and fine-grained control are all qualities that become increasingly valuable as infrastructure grows in scale. A data center containing thousands of machines rewards very different design decisions than a laptop sitting on an office desk — and, crucially, server purchasing decisions are rarely influenced by the backroom deals that shape consumer and educational markets.

Desktop users face a different optimization problem — one that Microsoft has actively shaped for decades through its control of OEM channels, educational partnerships, and file format standards. They care about software compatibility, hardware support, document interoperability, gaming performance, organizational requirements, and familiarity. These priorities are neither irrational nor uninformed; they are the direct consequence of an ecosystem that was deliberately closed, proprietary, and exclusionary. Engineers sometimes frame the Linux-versus-Windows debate as though one platform must be universally superior. In reality, both platforms evolved to serve different ecosystems with different expectations — but one ecosystem was built to serve users, while the other was built to serve a corporation's bottom line.

The Difference Between Engineering Merit and Market Dominance

There is a tendency among technically inclined communities to assume that market outcomes directly reflect technical merit. History repeatedly demonstrates otherwise, and Microsoft's trajectory is perhaps the clearest proof. The technologies that dominate industries are often the technologies that best align with existing incentives rather than those that achieve the highest score on an engineering checklist. Compatibility, timing, ecosystem size, vendor relationships — including relationships with politicians and procurement officers — institutional adoption, and user familiarity frequently outweigh architectural elegance.

This observation should not be interpreted as naivety about Linux's own shortcomings, but as a clear-eyed assessment of how anticompetitive behavior warps markets. Microsoft did not simply out-engineer its competition. It out-lobbied, out-negotiated, and in many cases out-manipulated it. The U.S. antitrust case of the late 1990s exposed tactics like per-processor licensing fees that penalized OEMs for offering alternative operating systems, exclusive deals that shut out competitors, and deliberate API obfuscation that sabotaged interoperability. European antitrust rulings later forced Microsoft to offer browser choice screens and document format disclosures. By then, however, the ecosystem was already entrenched, and the damage to competition on the desktop was largely done.

Conclusion

The question was never why Linux failed to replace Windows. In many of the most strategically important areas of computing, Linux has already achieved extraordinary success — often in spite of Microsoft's best efforts to undermine it. The more interesting question is why desktop computing evolved differently. The answer lies not in licensing costs, kernel architectures, or benchmark results but in the cumulative effect of decades of ecosystem engineering, much of it anticompetitive. Windows benefits from institutional momentum accumulated through education systems that Microsoft effectively purchased, business adoption driven by lock-in rather than choice, software availability built on exclusionary contracts, and distribution channels maintained through sheer market coercion.

The story of desktop operating systems is therefore not a story about which platform is technically better. It is a story about how a determined corporation captured an entire market by any means necessary — including buying influence over the very institutions that should have been teaching the next generation to think critically about technology. Viewed through that lens, the persistence of Windows on the desktop is not a sign of its superiority. It is a monument to the power of institutional capture, and a reminder that in technology, as in politics, the best product does not always win.

Automating Beautiful Quote Images with LaTeX and Bash

2026-05-02T14:48:45+00:00

Automating Beautiful Quote Images with LaTeX and Bash

In this tutorial, we explore a powerful Bash script that transforms plain text into visually rich quote images using LaTeX, TikZ, and ImageMagick. This workflow is especially useful for developers, writers, and content creators who want full control over typography and background styling without relying on external design tools.

🧠 Overview of the Workflow

The script follows a simple pipeline:

• Read input text from a file

• Apply LaTeX formatting with custom font and spacing

• Render a full-page background image using TikZ

• Compile the document using XeLaTeX

• Convert the resulting PDF into a high-quality image

This makes it ideal for generating consistent visual quotes or banners for blogs and social media.

⚙️ Script Breakdown

1. Input Handling and Configuration

The script begins by validating input and allowing optional font size customization:

  if [ -z "$1" ]; then
    echo "Usage: $0 input.txt [fontsize]"
    exit 1
fi

INPUT_FILE="$1"
FONTSIZE="${2:-82}"
BASELINE=$(($FONTSIZE + 12))

This gives flexibility to adjust typography dynamically without modifying the script.

2. Temporary Workspace and Output Paths

A temporary working directory is created to isolate compilation files:

WORKDIR="/tmp/latex_render_$RANDOM"
OUTPUT_DIR="$HOME/Pictures/quotes"

mkdir -p "$WORKDIR"
mkdir -p "$OUTPUT_DIR"

This ensures clean execution without cluttering the filesystem.

3. Background Image Optimization

The script processes a background image using ImageMagick:

magick "$BG_SRC" -resize 1920x -quality 70 "$BG_OPT"

This step reduces file size while maintaining visual quality, which is important for fast rendering.

4. LaTeX Document Generation

The core of the system is dynamically generating a LaTeX file with embedded content:

\documentclass[12pt,a4paper,landscape]{article}

\usepackage{tikz}
\usepackage{graphicx}
\usepackage{fontspec}
\usepackage{polyglossia}

\setmainlanguage[numerals=maghrib]{arabic}
\newfontfamily\arabicfont[Script=Arabic]{Amiri}

\AtBeginDocument{\fontsize{82}{94}\selectfont}

This setup enables:

• Arabic text rendering via polyglossia

• Custom font support with Amiri

• High-quality typography scaling

5. Full-Page Background with TikZ

The script overlays a background image across the entire page:

\begin{tikzpicture}[remember picture, overlay]
  \node at (current page.center) {
    \includegraphics[width=\paperwidth,height=\paperheight]{bg.jpg}
  };
\end{tikzpicture}

This approach ensures perfect full-page coverage without external design tools.

6. Compilation and Export

The LaTeX file is compiled twice for stability:

for i in 1 2; do
    xelatex -output-directory="$WORKDIR" "$TEX_FILE"
done

Then converted into a final optimized image:

magick -density 150 "$PDF_FILE" \
  -resize 1920x \
  -strip -quality 85 "$IMG_FILE"

This produces a lightweight yet sharp output image suitable for publishing.

Auto generated quote

The Full script

    
#!/usr/bin/env bash

set -e

# Check argument
if [ -z "$1" ]; then
    echo "Usage: $0 input.txt [fontsize]"
    exit 1
fi

INPUT_FILE="$1"

# Optional font size (default = 82)
FONTSIZE="${2:-82}"
BASELINE=$(($FONTSIZE + 12))  # decent spacing

# Timestamp (unique)
TIMESTAMP=$(date +"%Y%m%d_%H%M%S_%N")

# Paths
WORKDIR="/tmp/latex_render_$RANDOM"
OUTPUT_DIR="$HOME/Pictures/quotes"

mkdir -p "$WORKDIR"
mkdir -p "$OUTPUT_DIR"

TEX_FILE="$WORKDIR/output.tex"
PDF_FILE="$WORKDIR/output.pdf"
IMG_FILE="$OUTPUT_DIR/${TIMESTAMP}.jpg"

# Background image (optimized copy)
BG_SRC="/home/mosaid/Desktop/latex/parchment/parchment.jpg"
BG_OPT="$WORKDIR/bg.jpg"

# Resize + compress background
magick "$BG_SRC" -resize 1920x -quality 70 "$BG_OPT"

# Escape LaTeX special chars (basic)
CONTENT=$(sed 's/[#$%&_{}]/\\&/g' "$INPUT_FILE")

# Create LaTeX file
cat > "$TEX_FILE" <<EOF
\documentclass[12pt,a4paper,landscape]{article}
\usepackage[left=1cm,right=1cm,top=1cm,bottom=1cm]{geometry}

\usepackage{tikz}
\usepackage{graphicx}
\usepackage{setspace}

\usepackage{fontspec}
\usepackage{polyglossia}
\setmainlanguage[numerals=maghrib]{arabic}
\newfontfamily\arabicfont[Script=Arabic]{Amiri}

\setstretch{1.5}
\AtBeginDocument{\fontsize{$FONTSIZE}{$BASELINE}\selectfont}

\begin{document}

\begin{tikzpicture}[remember picture, overlay]
  \node at (current page.center) {
    \includegraphics[width=\paperwidth,height=\paperheight]{$BG_OPT}
  };
\end{tikzpicture}

\begin{center}
$CONTENT
\end{center}

\end{document}
EOF

# Compile LaTeX twice (TikZ stability)
for i in 1 2; do
    echo "$i compilation"
    xelatex -output-directory="$WORKDIR" "$TEX_FILE" >/dev/null
    sleep .5
done

# Convert PDF → optimized image
magick -density 150 "$PDF_FILE" \
  -resize 1920x \
  -strip -quality 85 "$IMG_FILE"

echo "✅ Image generated: $IMG_FILE"

🚀 Why This Script Is Powerful

This system combines multiple tools into a single automated pipeline:

• LaTeX → professional typography

• TikZ → precise layout control

• ImageMagick → image optimization

• Bash → full automation

The result is a reproducible and scriptable design system that does not depend on GUI tools.

📌 Final Thoughts

This workflow is especially useful for generating:

• Inspirational quote images

• Blog banners

• Social media visuals

• Arabic typography designs

With small adjustments, this script can evolve into a full content generation engine for visual storytelling.

Smart Brightness Control in Linux: Auto-Detect and Manage Backlight Like a Pro

2026-04-28T21:02:10+00:00

Managing screen brightness on Linux sounds trivial… until you realize your system exposes multiple brightness interfaces and only one of them actually works correctly.

I’ve personally run into systems where writing to /sys/class/backlight/acpi_video0/brightness does absolutely nothing, while another hidden interface works perfectly.

So instead of guessing every time, I built a smart brightness script that:

•Automatically detects the correct device

•Ignores broken or misleading interfaces

•Provides verbose debugging output

•Supports get / set / increment / decrement

🧠 Understanding the Problem

Linux exposes brightness controls through /sys, typically under:


/sys/class/backlight/
/sys/class/leds/

The issue? You might see something like:


/sys/class/backlight/intel_backlight
/sys/class/backlight/acpi_video0

But only one of them actually controls your screen.

•intel_backlight → usually correct (GPU native)

•acpi_video0 → often fake or limited

This is why hardcoding paths is a bad idea.

⚙️ The Smart Brightness Script

Here’s the full script I use. It automatically detects the best interface and gives you detailed output when needed.


#!/usr/bin/env bash

set -euo pipefail

STEP=5
VERBOSE=0

log() {
    [[ $VERBOSE -eq 1 ]] && echo "[brightness] $*" >&2
}

percent_to_raw() {
    local percent=$1 max=$2
    echo $(( percent * max / 100 ))
}

raw_to_percent() {
    local val=$1 max=$2
    echo $(( val * 100 / max ))
}

get_candidates() {
    local d

    for d in /sys/class/backlight/*; do
        [[ -d "$d" && -f "$d/brightness" && -f "$d/max_brightness" ]] && echo "$d"
    done

    for d in /sys/class/leds/*; do
        [[ -f "$d/brightness" && -f "$d/max_brightness" ]] && echo "$d"
    done
}

detect_device() {
    mapfile -t candidates < <(get_candidates)

    [[ ${#candidates[@]} -eq 0 ]] && return 1

    log "Found ${#candidates[@]} candidates:"
    for d in "${candidates[@]}"; do
        log "  - $d"
    done

    for d in "${candidates[@]}"; do
        if [[ "$d" == *intel_backlight* || "$d" == *amdgpu* ]]; then
            log "Selected (GPU native): $d"
            echo "$d"
            return
        fi
    done

    for d in "${candidates[@]}"; do
        if [[ "$d" != *acpi_video* ]]; then
            log "Selected (non-ACPI fallback): $d"
            echo "$d"
            return
        fi
    done

    log "Selected (last resort): ${candidates[0]}"
    echo "${candidates[0]}"
}

get_brightness() {
    local dev=$1
    local val max percent

    val=$(<"$dev/brightness")
    max=$(<"$dev/max_brightness")
    percent=$(raw_to_percent "$val" "$max")

    echo "Device: $dev"
    echo "Raw: $val / $max"
    echo "Brightness: ${percent}%"
}

set_brightness() {
    local dev=$1 percent=$2
    local max raw

    max=$(<"$dev/max_brightness")
    raw=$(percent_to_raw "$percent" "$max")

    log "Writing $raw to $dev/brightness (=${percent}%)"
    echo "$raw" | sudo tee "$dev/brightness" >/dev/null

    [[ $VERBOSE -eq 1 ]] && get_brightness "$dev"
}

list_devices() {
    local d val max percent

    mapfile -t candidates < <(get_candidates)

    [[ ${#candidates[@]} -eq 0 ]] && {
        echo "No brightness devices found"
        exit 1
    }

    for d in "${candidates[@]}"; do
        val=$(<"$d/brightness")
        max=$(<"$d/max_brightness")
        percent=$(raw_to_percent "$val" "$max")

        echo "$d"
        echo "  Raw: $val / $max"
        echo "  Brightness: ${percent}%"
        echo
    done
}

main() {
    local cmd="get"

    if [[ "${1:-}" == "-v" ]]; then
        VERBOSE=1
        shift
    fi

    cmd=${1:-get}
    shift || true

    case "$cmd" in
        list)
            list_devices
            return
            ;;
    esac

    local dev
    dev=$(detect_device) || {
        echo "No brightness device found"
        exit 1
    }

    case "$cmd" in
        get)
            get_brightness "$dev"
            ;;
        set)
            [[ $# -lt 1 ]] && { echo "Usage: $0 set <percent>"; exit 1; }
            set_brightness "$dev" "$1"
            ;;
        inc)
            local cur
            cur=$(raw_to_percent "$(<"$dev/brightness")" "$(<"$dev/max_brightness")")
            set_brightness "$dev" $(( cur + STEP ))
            ;;
        dec)
            local cur
            cur=$(raw_to_percent "$(<"$dev/brightness")" "$(<"$dev/max_brightness")")
            set_brightness "$dev" $(( cur - STEP ))
            ;;
        *)
            echo "Usage: $0 [-v] {get|set <n>|inc|dec|list}"
            exit 1
            ;;
    esac
}

main "$@"

⚡ Usage Examples

•Check current brightness


./brightness.sh get

•Enable verbose debugging


./brightness.sh -v get

•Set brightness to 50%


./brightness.sh set 50

•Increment / decrement


./brightness.sh inc
./brightness.sh dec

•List all detected devices


./brightness.sh list

🔐 Optional: Remove the Need for sudo

You can allow brightness control without sudo using a udev rule:


echo 'ACTION=="add", SUBSYSTEM=="backlight", RUN+="/bin/chmod 666 /sys/class/backlight/%k/brightness"' | sudo tee /etc/udev/rules.d/90-backlight.rules

🧠 Final Thoughts

What I like about this approach is that it’s portable, predictable, and transparent. Instead of relying on desktop environments or external tools, you get direct control over the kernel interface.

And more importantly—you always know which device is actually being used.

If you’re the kind of user who lives in the terminal or runs minimal setups like i3 or sway, this kind of script becomes essential.

🚀 Next Steps

If you want to push this further, here are some ideas:

•Bind it to XF86 brightness keys

•Add smooth fade transitions

•Cache the detected device for faster execution

•Add external monitor support via ddcutil

Once you start owning your system at this level, going back to GUI sliders feels… limiting.

Supercharging Zsh: Practical Functions and Keybindings for Power Users

2026-04-25T22:45:50+00:00

Introduction

If you're already using Zsh with Oh My Zsh, you're past the beginner stage. The real gains come from bending the shell to your workflow. In this guide, I walk through a set of practical functions and keybindings from my own .zshrc that significantly improve navigation, history usage, and editing efficiency.

These are not gimmicks — they solve real friction points in daily terminal usage.

1. Ranger-Powered Directory Switching (Ctrl+O)

Switching directories is something you do constantly. Typing paths is slow. Even tab completion gets in the way when navigating deep trees.

This function uses ranger as an interactive directory selector:


rrcd () {
    tmp="$(mktemp)"
    ranger --choosedir="$tmp"
    if [ -f "$tmp" ]; then
        dir="$(cat "$tmp")"
        rm -f "$tmp"
        [ -d "$dir" ] && [ "$dir" != "$(pwd)" ] && cd "$dir"
    fi
}

•Why it matters: You get a full-screen file browser to jump anywhere instantly.

•Bound to: Ctrl+O


bindkey -s '^o' 'rrcd\n'

2. Edit Command Line in Vim (Ctrl+E)

Long commands are painful to edit inline. This solves it by opening your current command in Neovim:


autoload edit-command-line; zle -N edit-command-line
bindkey '^e' edit-command-line

•Why it matters: You get full Vim motions, search, macros — not just arrow keys.

3. Smarter History with FZF

Ctrl+R — Fuzzy Search History


bindkey "^R" fzf-history-widget

• Ranking by relevance

• Full preview of matches

• Instant filtering

Directory Jump from History (Ctrl+S / Ctrl+A)


fzf-cd-history() {
  local dir
  dir=$(fc -ln 1 | tac | grep --color=never '^cd ' | sed 's/^cd //' | \
        fzf --height 40% --cycle)

  if [[ -d "$dir" ]]; then
    cd "$dir"
  else
    local base="${dir##*/}"
    dir=$( (find ~ -type d -name "$base" 2>/dev/null) | \
          fzf --height 40% --cycle --no-sort --tac \
              --bind "change:reload(find ~ -type d -name '$base' 2>/dev/null || echo 'No results')" \
              --phony --header="Looking for '$base'..." )

    [[ -n "$dir" && "$dir" != "Searching for directories"* ]] && cd "$dir"
  fi
  zle reset-prompt
}


bindkey '^S' fzf-cd-history
bindkey '^A' fzf-cd-history

4. Open Recent Files from Vim History (Ctrl+V)


fzf-vim-history() {
  local file
  local files

  files=$(
    {
      nvim --headless +'lua for _,f in ipairs(vim.v.oldfiles) do print(f) end' +q 2>&1
    } | tr -d '\r' | awk '!seen[$0]++'
  )

  file=$(printf '%s\n' "$files" | fzf --no-sort --height 40% --cycle)

  if [[ -n "$file" ]]; then
    LBUFFER="v \"$file\""
    zle reset-prompt
  fi
}


bindkey '^V' fzf-vim-history

5. Instant Sudo Toggle (Double ESC)


sudo-command-line() {
    [[ -z $BUFFER ]] && zle up-history
    if [[ $BUFFER == sudo\ * ]]; then
        LBUFFER="${LBUFFER#sudo }"
    else
        LBUFFER="sudo $LBUFFER"
    fi
}
zle -N sudo-command-line
bindkey "\e\e" sudo-command-line

6. High-Performance History Configuration


HISTSIZE=999999999
SAVEHIST=$HISTSIZE

setopt APPEND_HISTORY
setopt SHARE_HISTORY
setopt HIST_IGNORE_DUPS
setopt HIST_REDUCE_BLANKS
setopt HIST_IGNORE_SPACE
setopt HIST_NO_STORE
setopt HIST_SAVE_NO_DUPS
setopt HIST_EXPIRE_DUPS_FIRST

7. Completion System Tuning


zstyle ':completion:*' matcher-list '' 'm:{a-z}={A-Z}'
zstyle ':completion:*' menu select=long
zstyle ':completion:*' verbose true

8. Subtle UX Improvements


bindkey '^[[1;5C' forward-word
bindkey '^[[1;5D' backward-word
bindkey "^[[A" history-search-backward
bindkey "^[[B" history-search-forward

9. Notes Injection Before Commands


my_preexec() {
    if [[ "$1" != "cat $HOME/.todo"* ]]; then
        [[ -f "$HOME/.todo" ]] && cat "$HOME/.todo"
    fi
}

Conclusion

This setup works because it removes friction:

• Navigation becomes interactive

• History becomes searchable

• Editing becomes programmable

The shell stops being a command runner and becomes a real interface.

Automating Video Speed-Up and Audio Replacement with FFmpeg and Bash

2026-04-24T00:19:42+00:00

In this tutorial, we are not just writing a quick script — we are building a reusable video processing workflow around FFmpeg and Bash.

The goal is simple on the surface:

• Speed up a video

• Remove its original audio

• Replace it with a looping background track

But instead of treating this as a one-off command, we will break down the why, the mechanics, and the trade-offs, so you can extend this into your own pipelines.

1. The Complete Script

Let’s start with the full working version:

    
#!/bin/bash

set -e

INPUT="$1"
SPEED_FACTOR="${2:-3}"

if [ -z "$INPUT" ]; then
    echo "Usage: $0 input_video.mkv [speed]"
    exit 1
fi

AUDIO_DIR="/home/mosaid/Documents/audio"

echo "Available audio files:"
mapfile -t AUDIO_FILES <<(find "$AUDIO_DIR" -maxdepth 1 -type f -name "*.mp3")

if [ ${#AUDIO_FILES[@]} -eq 0 ]; then
    echo "No mp3 files found."
    exit 1
fi

for i in "${!AUDIO_FILES[@]}"; do
    echo "$((i+1))) $(basename "${AUDIO_FILES[$i]}")"
done

read -rp "Choose an audio file: " AUDIO_CHOICE

AUDIO="${AUDIO_FILES[$((AUDIO_CHOICE-1))]}"

BASENAME="$(basename "${INPUT%.*}")"
MUTED="$(mktemp --suffix=.mp4)"
SPEED="$(mktemp --suffix=.mp4)"
FINAL="${BASENAME}-final.mp4"

ffmpeg -y -i "$INPUT" -c:v copy -an "$MUTED"

ffmpeg -y -i "$MUTED" -filter:v "setpts=PTS/${SPEED_FACTOR}" "$SPEED"

ffmpeg -y -stream_loop -1 -i "$AUDIO" -i "$SPEED" -shortest \
  -map 1:v -map 0:a -c:v copy -c:a aac "$FINAL"

rm -f "$MUTED" "$SPEED"

echo "Output: $FINAL"

2. Understanding the Pipeline

This script is intentionally split into three distinct FFmpeg passes. That is not accidental.

• Pass 1 → Strip audio

• Pass 2 → Modify video timing

• Pass 3 → Rebuild final container

This separation keeps each step predictable and avoids subtle FFmpeg sync issues that often appear in one-liners.

3. Why We Remove Audio First

    
ffmpeg -y -i "$INPUT" -c:v copy -an "$MUTED"

•-c:v copy → No re-encoding (this is critical for performance)

•-an → Drop all audio streams

Why do this first?

• It guarantees a clean base (no leftover streams)

• It avoids audio/video desync after time manipulation

• It keeps the pipeline deterministic

Power-user insight:

If you skip this step and try to manipulate both streams at once, FFmpeg may keep timestamps that no longer align.

4. The Core Concept: setpts

    
ffmpeg -y -i "$MUTED" -filter:v "setpts=PTS/${SPEED_FACTOR}" "$SPEED"

This is the heart of the script.

•PTS = Presentation Timestamp

• Every frame has a timestamp that determines when it is displayed

When you write:

• PTS/3 → Frames are shown 3× faster

• PTS*2 → Frames are shown slower

So we are not "dropping frames" or "changing FPS" — we are modifying time itself at the container level.

This is why the operation is both:

• Efficient

• Precise

Advanced Note

If you wanted to also adjust audio speed (instead of replacing it), you would need:

    
-filter:a "atempo=2.0"

But here we intentionally discard audio entirely, which simplifies everything.

5. Looping Audio Without Guessing Duration

    
ffmpeg -y -stream_loop -1 -i "$AUDIO" -i "$SPEED" -shortest \
  -map 1:v -map 0:a -c:v copy -c:a aac "$FINAL"

This is a very clean pattern that many people overlook.

•-stream_loop -1 → Infinite loop

•-shortest → Output stops when video ends

This avoids:

• Manually trimming audio

• Calculating durations

• Writing fragile logic

Stream Mapping (Important)

•-map 1:v → Take video from second input

•-map 0:a → Take audio from first input

Without this, FFmpeg may choose streams implicitly — which is unreliable in automation scripts.

6. Temporary Files Strategy

    
MUTED="$(mktemp --suffix=.mp4)"
SPEED="$(mktemp --suffix=.mp4)"

Using mktemp instead of fixed filenames is a small but important detail:

• Prevents collisions

• Makes the script safe for parallel execution

• Avoids accidental overwrites

This is one of those habits that separates quick scripts from robust tooling.

7. Interactive Selection vs Automation

The script uses:

    
mapfile -t AUDIO_FILES  <<(find "$AUDIO_DIR" -name "*.mp3")

This is simple and portable — but not optimal for heavy usage.

Upgrade: fzf Integration

    
AUDIO=$(find "$AUDIO_DIR" -type f -name "*.mp3" | fzf)

• Instant fuzzy search

• No manual indexing

• Better UX for large libraries

This is the kind of improvement power users appreciate immediately.

8. Performance Considerations

This pipeline is efficient because:

• No video re-encoding (stream copy)

• Only one transformation step (PTS)

• Lightweight final muxing

However:

• The setpts step does require re-encoding

• That is unavoidable when modifying timestamps

If performance becomes critical, you can:

• Use hardware acceleration (VAAPI / NVENC)

• Lower resolution before processing

9. Turning This Into a Real Tool

Right now, this is a script. With small changes, it becomes a proper CLI utility:

• Add flags (-i, -s, -a)

• Add logging

• Add dry-run mode

• Add batch processing

Example batch usage:

    
for f in *.mkv; do
    ./process.sh "$f" 2
done

10. Where This Fits in Real Workflows

This pattern is surprisingly useful:

•Lecture acceleration: compress hours into minutes

•Content pipelines: generate background visuals

•Automation: integrate with cron or systemd

•Media cleanup: replace poor audio tracks

And more importantly:

• It composes well with other Unix tools

Final Thoughts

The real takeaway here is not the script itself — it is the approach:

• Break pipelines into deterministic steps

• Understand what FFmpeg is doing internally

• Prefer explicit mapping and control

Once you think this way, FFmpeg stops being a "command generator" and becomes a reliable building block in your system.

From here, you can extend this into a full automation pipeline, integrate it into your desktop workflow, or even expose it as a service.

From Terminal to Desktop: Sticky Todo Reminders with Cron, systemd & Conky

2026-04-19T12:12:38+00:00

In the previous tutorial, I built a minimal terminal-based reminder system using cron and a simple .todo file.

Now, let’s take it further.

In this guide, I’ll turn that idea into a desktop-integrated reminder system using:

•Cron: to generate reminders

•systemd (user): to monitor tasks

•Conky: to display sticky notes on your desktop

This creates a lightweight, always-visible reminder system—without relying on heavy applications.

💡 Architecture Overview

The system works like this:

•Cron: writes reminders to ~/.todo

•systemd user service: checks if tasks exist

•Conky: displays them as sticky notes

Everything stays simple, modular, and hackable.

📁 Step 1: Base Todo System (Recap)

Create the file:

   
touch ~/.todo

Add a weekly cron job:

   
crontab -e

   
0 9 * * 1 echo "$(date '+%F %R') - Run sudo pacman -Syu" >> /home/mosaid/.todo

⚙️ Step 2: Create a systemd User Service

We now create a service that checks if the todo file has content.

Create the file:

   
mkdir -p ~/.config/systemd/user
vim ~/.config/systemd/user/todo-check.service

Content:

   
[Unit]
Description=Check TODO file and trigger display

[Service]
Type=oneshot
ExecStart=/usr/bin/bash -c '[ -s /home/mosaid/.todo ]'

This simply checks if the file is non-empty.

⏱️ Step 3: Add a systemd Timer

Create a timer that runs every few minutes:

   
vim ~/.config/systemd/user/todo-check.timer

   
[Unit]
Description=Run TODO check every 5 minutes

[Timer]
OnBootSec=1min
OnUnitActiveSec=5min

[Install]
WantedBy=timers.target

Enable it:

   
systemctl --user daemon-reexec
systemctl --user enable --now todo-check.timer

🖥️ Step 4: Conky Sticky Notes

This is where things become visual.

Create a Conky config:

   
mkdir -p ~/.config/conky
vim ~/.config/conky/todo.conf

   
conky.config = {
    alignment = 'top_right',
    gap_x = 20,
    gap_y = 50,
    background = true,
    double_buffer = true,
    own_window = true,
    own_window_type = 'desktop',
    own_window_transparent = true,
    use_xft = true,
    font = 'DejaVu Sans Mono:size=10',
    update_interval = 5,
};

conky.text = [[
${color cyan}---- TODO ----${color}
${execi 5 tail -n 10 /home/mosaid/.todo}
]];

Run it:

   
conky -c ~/.config/conky/todo.conf &

You now have a live sticky todo list on your desktop.

✨ Step 5: Improve Visibility

Add colors and formatting:

   
${color green}${time %Y-%m-%d}${color}

Or highlight updates:

   
${execi 5 grep --color=always pacman /home/mosaid/.todo}

🧠 Optional: Auto-Hide When Empty

You can extend the systemd service to kill Conky if no tasks exist:

   
ExecStart=/usr/bin/bash -c '[ -s ~/.todo ] || pkill conky'

And restart it when tasks appear.

🚀 Extensions

•Multiple todo files: work, personal, system

•Git sync: share reminders across machines

•Notifications: integrate with notify-send

•Conky themes: match your desktop style

⚖️ Why This Setup is Powerful

•Persistent: visible on desktop at all times

•Lightweight: near-zero resource usage

•Modular: each component is independent

•Fully controllable: no black boxes

This is the kind of system that scales with your needs.

🏁 Conclusion

You’ve now transformed a simple terminal trick into a fully integrated desktop reminder system.

It respects the Unix philosophy while giving you a modern workflow.

Small tools. Big control.

Build a Zero-Dependency Terminal Reminder System (Cron + Shell)

2026-04-19T11:52:30+00:00

As Linux users, we often rely on heavy tools for things that could be solved with a few lines of shell. In this tutorial, I’ll show you how I built a zero-dependency reminder system that lives entirely in the terminal.

No GUI. No background apps. No distractions. Just a clean, minimal workflow that reminds you of important tasks like system updates.

💡 The Idea

The concept is simple:

•Step 1: A cron job writes reminders to a file

•Step 2: Your shell displays that file on startup

•Step 3: You see reminders naturally when opening a terminal

This turns your shell into a passive notification system.

📁 Step 1: Create a Reminder File

We’ll store reminders in a simple file:

touch ~/.todo

This file will act as your lightweight task list.

⏰ Step 2: Add a Weekly Cron Job

Edit your crontab:


crontab -e

Add the following line:


0 9 * * 1 echo "$(date '+%Y-%m-%d %H:%M') - Run sudo pacman -Syu" >> /home/mosaid/.todo

•Explanation:

•0 9 * * 1: Every Monday at 09:00

•echo: Adds a timestamped reminder

•>>: Appends instead of overwriting

🖥️ Step 3: Display Reminders in Your Shell

Now we make the reminders visible when opening a terminal.

For Bash:


echo 'cat ~/.todo' >> ~/.bashrc

For Zsh:


echo 'cat ~/.todo' >> ~/.zshrc

Now every new terminal session will display your reminders automatically.

✨ Step 4: Make It Cleaner

Instead of dumping the entire file, show only recent entries:


tail -n 5 ~/.todo

Update your shell config:


echo 'echo "---- TODO ----"' >> ~/.bashrc
echo 'tail -n 5 ~/.todo' >> ~/.bashrc

🎨 Optional: Highlight Important Tasks


grep --color=always pacman ~/.todo

This makes update reminders stand out visually.

🧹 Optional: Clean Completed Tasks

Once you’ve updated your system, remove the reminder:


sed -i '/pacman -Syu/d' ~/.todo

You can also automate cleanup if needed.

🚀 Extending the System

This is where things get interesting. You can easily expand this idea:

•Backups: Weekly backup reminders

•Disk cleanup: Notify when to clean cache

•Security: Remind yourself to check logs

•Multiple machines: Sync .todo with git

You now have a fully customizable reminder system.

⚖️ Cron vs Systemd Timers

Cron is simple and works everywhere, but modern systems also support systemd timers.

•Cron: Easy, universal, quick setup

•Systemd timers: More robust, better logging, tighter integration

If you want a more advanced setup, consider migrating later.

🧠 Why This Works

This approach is powerful because:

•No dependencies: Uses only built-in tools

•Zero overhead: No background services

•Contextual: Appears exactly when you open a terminal

•Hackable: Fully customizable to your workflow

It embraces the Unix philosophy: do one thing well.

🏁 Conclusion

What started as a simple cron job becomes a flexible, minimal reminder system that integrates seamlessly into your daily workflow.

Sometimes, the best tools aren’t the most complex—they’re the ones you fully control.

Play Quranic Ayat and Surahs from the Command Line

2025-01-25T09:43:19+00:00

Play Quran Ayat with a Shell Script

If you're someone who enjoys listening to Quranic recitations and prefers an automated way to play specific ayat or surahs, this script might be your new favorite tool. It uses files downloaded from EveryAyah and organizes them for seamless playback.

Script Overview: play-ayat

The play-ayat script lets you play Quranic ayat by specifying their numbers and optional ranges. Here's how it works:

•Arguments:

- first_number: The surah number (e.g., 001 for Al-Fatiha).

- second_number: The starting ayah number (e.g., 001).

- [end_range]: (Optional) The ending ayah number for a range of ayat to play.

- [speed]: (Optional) Playback speed (defaults to 1.15x).

How It Works

•Single Ayah Playback: When only the first_number and second_number are provided, the script constructs the filename using a padded three-digit format (e.g., 001001.mp3 for Al-Fatiha, Ayah 1). It checks if the file exists and plays it using mpv with custom player settings.

    

./play-ayat 1 1

•Range of Ayat: If the end_range is specified, the script builds a playlist (ayatplaylist.m3u) containing all ayat in the specified range. This playlist is then fed into mpv for playback.

    

./play-ayat 1 1 7

•Custom Playback Speed: You can optionally pass a speed argument to modify the playback speed. For example, to slow it down:

    

./play-ayat 1 1 7 0.9

The `play-ayat` script

    

#!/bin/bash

# Check for at least two arguments
if [ "$#" -lt 2 ]; then
    echo "Usage: $0 <first_number> <second_number> [<end_range>]"
    exit 1
fi

# Extract arguments
first_number=$1
second_number=$2
end_range=$3
if [[ -n $4 ]]
  then speed=$4
  else speed=1.15
fi

# Variables
FILES_DIR="$HOME/Music/Abdul Basit Mujawwad"
#FILES_DIR="$HOME/Music/Minshawy Mujawwad"
#FILES_DIR="$HOME/Music/Minshawy Murattal"
PLAYLIST_FILE="/tmp/ayatplaylist.m3u"
PLAYER_CONFIG="--no-terminal --no-config --no-pause --no-loop-file --speed=$speed"


# Format numbers to three digits
pfirst_number=$(printf "%03d" "$first_number")
psecond_number=$(printf "%03d" "$second_number")

# Check if end_range is provided
if [ -z "$end_range" ]; then
    # Single file case
    filename="${pfirst_number}${psecond_number}.mp3"
    full_path="${FILES_DIR}/${filename}"

    if [ -f "$full_path" ]; then
    mpv $PLAYER_CONFIG "$full_path" > /dev/null 2>&1
    fi
else
    # Range of files case
    # Clear or create playlist file
    echo "#EXTM3U" > "$PLAYLIST_FILE"
    for ((i=second_number; i<=end_range; i++)); do
        current_number=$(printf "%03d" "$i")
        filename="${pfirst_number}${current_number}.mp3"
        full_path="${FILES_DIR}/${filename}"
        if [ -f "$full_path" ]; then
            echo "$full_path" >> "$PLAYLIST_FILE"
        fi
    done

    if [ -s "$PLAYLIST_FILE" ]; then
    mpv $PLAYER_CONFIG --playlist-start=0 "$PLAYLIST_FILE" > /dev/null 2>&1
    fi
fi

Extending the Script: play-surah

The play-surah script takes this functionality further by automating the playback of an entire surah. Instead of specifying individual ayat, you can simply pass the surah number as the mandatory argument, and it will play all available ayat for that surah.

•Arguments:

- surah_number: The mandatory surah number (e.g., 001 for Al-Fatiha).

- [start_ayah]: (Optional) The starting ayah number.

- [end_ayah]: (Optional) The ending ayah number.

•Logic: If no start_ayah and end_ayah are provided, the script loops from Ayah 1 to a reasonable maximum (e.g., 300). Files are checked for existence, and a playlist is dynamically generated.

Code Example for play-surah

    

#!/bin/bash

# Check arguments
if [ "$#" -lt 1 ]; then
    echo "Usage: $0 <surah_number> [<start_ayah> <end_ayah>]"
    exit 1
fi

surah_number=$1
start_ayah=${2:-1}
end_ayah=${3:-300}
FILES_DIR="$HOME/Music/Abdul Basit Mujawwad"
PLAYLIST_FILE="/tmp/surahplaylist.m3u"
PLAYER_CONFIG="--no-terminal --no-config --no-pause --no-loop-file"

# Format surah number
psurah_number=$(printf "%03d" "$surah_number")

# Create playlist
echo "#EXTM3U" > "$PLAYLIST_FILE"
for ((i=start_ayah; i<=end_ayah; i++)); do
    payah_number=$(printf "%03d" "$i")
    filename="${psurah_number}${payah_number}.mp3"
    full_path="${FILES_DIR}/${filename}"
    if [ -f "$full_path" ]; then
        echo "$full_path" >> "$PLAYLIST_FILE"
    fi
done

if [ -s "$PLAYLIST_FILE" ]; then
    mpv $PLAYER_CONFIG --playlist-start=0 "$PLAYLIST_FILE" > /dev/null 2>&1
else
    echo "No files found for Surah $surah_number in the specified range."
fi

Usage Example for play-surah

•Play all ayat of a surah:

    

./play-surah 1

•Play a specific range of ayat within a surah:

    

./play-surah 2 255 286

Conclusion

These scripts bring simplicity and flexibility to Quranic recitation playback. Whether you're studying, meditating, or simply enjoying the beauty of the recitation, play-ayat and play-surah automate the process, saving you from manually selecting files.

With a little creativity, you could further extend these scripts for more advanced features like randomizing ayat, creating thematic playlists, or even integrating them into a larger application. which I did, stay tuned for more

Discover GNOME with these 25 Stunning Desktop Screenshots

2024-12-31T12:58:25+00:00

Introduction to GNOME Desktop Environment

GNOME stands out as a modern, intuitive, and minimalistic desktop environment. Its focus on simplicity and productivity has made it a favorite among Linux users. In this gallery, we present 25 stunning images that demonstrate the elegance and functionality of the GNOME desktop.

Why GNOME?

•Streamlined Interface: GNOME is designed with a focus on user experience, offering a clean and uncluttered interface.

•Efficient Workflow: With features like Activities Overview and keyboard shortcuts, GNOME optimizes your productivity.

•Modern Aesthetics: Sleek design elements and polished animations make GNOME visually appealing.

Gallery: GNOME Desktop Highlights

Here are 25 images that showcase the best of GNOME Desktop:

Gnome Desktop Screenshot 1

Gnome Desktop Screenshot 2

Gnome Desktop Screenshot 3

Gnome Desktop Screenshot 4

Gnome Desktop Screenshot 5

Gnome Desktop Screenshot 6

Gnome Desktop Screenshot 7

Gnome Desktop Screenshot 8

Gnome Desktop Screenshot 9

Gnome Desktop Screenshot 10

Gnome Desktop Screenshot 11

Gnome Desktop Screenshot 12

Gnome Desktop Screenshot 13

Gnome Desktop Screenshot 14

Gnome Desktop Screenshot 15

Gnome Desktop Screenshot 16

Gnome Desktop Screenshot 17

Gnome Desktop Screenshot 18

Gnome Desktop Screenshot 19

Gnome Desktop Screenshot 20

Gnome Desktop Screenshot 21

Gnome Desktop Screenshot 22

Gnome Desktop Screenshot 23

Gnome Desktop Screenshot 24

Gnome Desktop Screenshot 25

Conclusion

GNOME offers a balance of simplicity and power, making it an excellent choice for both new and experienced Linux users. Its elegant design and intuitive features are reflected in the gallery above. Ready to explore GNOME further? Visit the official GNOME website and experience it for yourself!

Discover the Beauty of KDE Plasma with These 30 Screenshots

2024-12-30T21:13:58+00:00

Introduction to KDE Plasma Desktop

KDE Plasma is celebrated for its versatility, stunning visuals, and user-centric design. In this gallery, we showcase 30 handpicked images that highlight the beauty and flexibility of KDE Plasma. Whether you're new to KDE or a seasoned user, these visuals will inspire you to explore this amazing desktop environment.

Why Choose KDE Plasma?

•Customization: From widgets to window decorations, KDE Plasma allows you to tailor your desktop to suit your preferences.

•Performance: Lightweight and efficient, KDE Plasma delivers a smooth experience even on older hardware.

•Modern Aesthetics: With stunning themes and polished icons, KDE Plasma offers a contemporary look and feel.

Gallery: The Elegance of KDE Plasma

Here are 30 stunning screenshots that showcase the best of KDE Plasma:

KDE Plasma Desktop Screenshot 1

KDE Plasma Desktop Screenshot 2

KDE Plasma Desktop Screenshot 3

KDE Plasma Desktop Screenshot 4

KDE Plasma Desktop Screenshot 5

KDE Plasma Desktop Screenshot 6

KDE Plasma Desktop Screenshot 7

KDE Plasma Desktop Screenshot 8

KDE Plasma Desktop Screenshot 9

KDE Plasma Desktop Screenshot 10

KDE Plasma Desktop Screenshot 11

KDE Plasma Desktop Screenshot 12

KDE Plasma Desktop Screenshot 13

KDE Plasma Desktop Screenshot 14

KDE Plasma Desktop Screenshot 15

KDE Plasma Desktop Screenshot 16

KDE Plasma Desktop Screenshot 17

KDE Plasma Desktop Screenshot 18

KDE Plasma Desktop Screenshot 19

KDE Plasma Desktop Screenshot 20

KDE Plasma Desktop Screenshot 21

KDE Plasma Desktop Screenshot 22

KDE Plasma Desktop Screenshot 23

KDE Plasma Desktop Screenshot 24

KDE Plasma Desktop Screenshot 25

KDE Plasma Desktop Screenshot 26

KDE Plasma Desktop Screenshot 27

KDE Plasma Desktop Screenshot 28

KDE Plasma Desktop Screenshot 29

KDE Plasma Desktop Screenshot 30

Conclusion

KDE Plasma is not just a desktop environment; it's an experience. With its unmatched flexibility, eye-catching design, and powerful tools, it caters to every user's needs. We hope this gallery inspires you to explore KDE Plasma further and customize your desktop to reflect your personality.

If you’re new to KDE, visit the official KDE Plasma website to learn more and get started today!

Why You Should Switch to Linux

2024-06-05T19:10:12+00:00

In the three decades since its inception, Linux has steadily grown from an obscure operating system used by a niche group of enthusiasts to a dominant force in the realm of servers and mobile devices. Today, Linux powers over 70% of the world's smartphones and servers, showcasing its robustness and reliability. However, its adoption on desktop computers remains relatively modest, with a market share of around 4%. Despite this, recent years have witnessed a resurgence in interest and development within the Linux ecosystem, making it more user-friendly and accessible than ever before.

Linux Today: A Mature and Versatile Ecosystem

Gone are the days when setting up wireless, Bluetooth, and printer devices on Linux was a frustrating ordeal. Today, most hardware works seamlessly with Linux, often requiring no more than a simple plug-and-play setup. The software landscape has also evolved significantly. Many popular applications now have native Linux versions, and where they don’t, robust alternatives or compatibility layers, such as Wine and Proton, fill the gap. Gaming on Linux, once a major hurdle, has seen substantial improvements thanks to platforms like Steam Play, which allow many Windows games to run on Linux with minimal hassle.

The Dark Cloud Over Windows

While Linux is on an upward trajectory, the future of Windows raises serious privacy concerns. Microsoft recently announced its “Copilot+ PC” initiative, a suite of powerful laptops designed to leverage the latest advancements in artificial intelligence, particularly the GPT-4o model from OpenAI. This model boasts impressive vision and audio capabilities, enabling real-time interactions that are deeply integrated into the operating system.

One of the most alarming features introduced with this update is “Recall,” which takes periodic screenshots of your screen, ostensibly to help you retrieve information and activities from your past sessions. This feature records all your digital interactions, from typing passwords to browsing family photos, watching movies, and managing anonymous online accounts. Essentially, it captures a comprehensive log of your digital life.

The Privacy Nightmare

The implications of such pervasive monitoring are profound. Even if Microsoft assures users that this feature is opt-in and that privacy protections are in place, the potential for misuse and security breaches is immense. Imagine a world where every keystroke, every private moment spent on your computer, is recorded and stored. This isn't just a hypothetical scenario; it's a looming reality that Microsoft seems eager to normalize.

Why You Should Consider Linux

In light of these developments, the case for switching to Linux becomes compelling not just from a feature standpoint, but from a privacy perspective as well. Linux, with its open-source nature, offers transparency and control over your operating system that proprietary software simply cannot match. You decide what gets installed, what gets tracked, and how your data is handled. This level of control is crucial in an era where privacy is increasingly under threat.

Switching to Linux might seem daunting if you're accustomed to the Windows ecosystem, but the transition is easier than you might think. Modern Linux distributions like Ubuntu, Fedora, and Manjaro provide user-friendly interfaces and extensive online support communities. Additionally, many of the tools and applications you rely on are either available on Linux or have suitable alternatives.

Conclusion

The technological landscape is evolving rapidly, and with it, the norms and expectations around privacy and user control. Microsoft's latest moves with Windows highlight a future where convenience and AI integration come at the cost of personal privacy. By contrast, Linux offers a path that prioritizes user autonomy and security. As the digital world becomes more intrusive, embracing Linux isn't just a choice of operating system—it's a stand for privacy and control in an increasingly monitored world.

How to Create an ISO from a Directory in Linux

2024-06-03T23:13:29+00:00

Creating an ISO image from a directory in Linux can be done using the mkisofs or genisoimage command. Follow these steps:

1. Install mkisofs or genisoimage

If you don't have mkisofs or genisoimage installed, you can install it using your package manager. For most Linux distributions, the package is named genisoimage.

For Debian-based distributions (like Ubuntu):



sudo apt-get install genisoimage

For Red Hat-based distributions (like Fedora):



sudo yum install genisoimage

2. Create the ISO

Use the mkisofs or genisoimage command to create the ISO. The basic syntax is:



mkisofs -o output.iso /path/to/directory



genisoimage -o output.iso /path/to/directory

Example:



mkisofs -o mydisk.iso /home/user/myfolder



genisoimage -o mydisk.iso /home/user/myfolder

3. Additional Options

You can use various options with mkisofs or genisoimage to customize the ISO creation process. Some common options include:

-V "Volume Label": Sets the volume label.
-R: Enables Rock Ridge extensions, which are useful for retaining file permissions and longer filenames.
-J: Enables Joliet extensions, which allow the ISO to be read by Windows systems.

Example with additional options:



mkisofs -o mydisk.iso -V "MY_DISK" -R -J /home/user/myfolder



genisoimage -o mydisk.iso -V "MY_DISK" -R -J /home/user/myfolder

After running the command, you will have an ISO file named output.iso (or mydisk.iso in the examples) that contains the contents of the specified directory.

How to Use setfacl and getfacl: A Step-by-Step Guide

2024-05-25T15:33:25+00:00

Introduction to ACLs

Access Control Lists (ACLs) are used to provide more fine-grained permissions for files and directories than the traditional Unix permissions (read, write, execute). They allow you to specify permissions for individual users or groups.

setfacl and getfacl

setfacl is used to set ACLs on files and directories.
getfacl is used to retrieve ACLs from files and directories.

Basic Syntax

setfacl



setfacl [options] acl_spec file...

getfacl



getfacl [options] file...

Setting ACLs with setfacl

Basic Usage

To add an ACL entry:



setfacl -m u:username:permissions file

-m: Modify the ACL.
u:username:permissions: Specify the user (u), the username, and the permissions (r, w, x).

Example:



setfacl -m u:john:rwx myfile

This grants user john read, write, and execute permissions on myfile.

Setting ACLs for Groups



setfacl -m g:groupname:permissions file

Example:



setfacl -m g:admins:rw myfile

This grants the group admins read and write permissions on myfile.

Setting Default ACLs on Directories



setfacl -d -m u:username:permissions directory

Example:



setfacl -d -m u:john:rwx mydir

This sets default permissions for john on the directory mydir.

Removing ACL Entries

To remove an ACL entry:



setfacl -x u:username file

Example:



setfacl -x u:john myfile

This removes the ACL entry for user john on myfile.

To remove all ACL entries:



setfacl -b file

Example:



setfacl -b myfile

This removes all ACL entries from myfile.

Viewing ACLs with getfacl

To view the ACLs on a file or directory:



getfacl file

Example:



getfacl myfile

This outputs the ACLs for myfile.

Example Output



# file: myfile
# owner: root
# group: root
user::rw-
user:john:rwx
group::r--
mask::rwx
other::r--

user::rw- - Permissions for the file owner.
user:john:rwx - Specific permissions for user john.
group::r-- - Permissions for the owning group.
mask::rwx - The effective rights mask.
other::r-- - Permissions for others.

Recursive ACLs

To apply ACLs recursively to all files and directories within a directory:



setfacl -R -m u:username:permissions directory

Example:



setfacl -R -m u:john:rwx mydir

This applies the ACL for john recursively within mydir.

Preserving Existing ACLs

To add or modify ACL entries without affecting existing ones, use the -n option with setfacl.



setfacl -n -m u:username:permissions file

Example:



setfacl -n -m u:john:rwx myfile

Conclusion

ACLs provide a powerful way to manage permissions on a more granular level than standard Unix permissions. Using setfacl, you can set and modify ACLs, while getfacl allows you to view them. This capability is especially useful in environments where multiple users or groups need specific access to files and directories.

How to Check SSD Health in Linux: A Comprehensive Guide

2024-05-21T20:05:15+00:00

How to Check SSD Health and Information in Linux

Solid State Drives (SSDs) are crucial components in modern computers, offering faster data access speeds compared to traditional Hard Disk Drives (HDDs). To ensure optimal performance and longevity of your SSD, it is essential to regularly monitor its health and status. This article will guide you through the process of checking SSD health and retrieving relevant information on a Linux system.

Prerequisites

Before you begin, ensure you have access to a terminal and administrative privileges (root access or the ability to use sudo). The steps outlined here are applicable to most Linux distributions.

Using `smartctl` from the `smartmontools` Package

The smartctl tool, part of the smartmontools package, is widely used for monitoring and managing storage devices. It supports most SSDs and provides comprehensive health information.

1. Install `smartmontools`

First, install the smartmontools package. The installation command varies depending on your Linux distribution:

Debian/Ubuntu:


sudo apt-get update
sudo apt-get install smartmontools

Fedora:
```
sudo dnf install smartmontools
```
Arch Linux:
```
sudo pacman -S smartmontools
```

2. Check SSD Health

After installation, you can use smartctl to check the health status of your SSD. Replace /dev/sdX with your SSD's device identifier (e.g., /dev/sda, /dev/nvme0n1).

To view the overall health of the SSD, use the following command:


sudo smartctl -H /dev/sdX

3. Detailed SSD Information

For more detailed information, including SMART attributes, run:


sudo smartctl -a /dev/sdX

This command provides a comprehensive report, including the SSD model, firmware version, and various health indicators such as temperature, power-on hours, and error rates.

4. Running a Self-Test

You can also initiate self-tests to evaluate the SSD's condition. For a short self-test, use:


sudo smartctl -t short /dev/sdX

For a longer, more thorough test, use:


sudo smartctl -t long /dev/sdX

Check the test results with:


sudo smartctl -l selftest /dev/sdX

Using `nvme-cli` for NVMe SSDs

If your system uses NVMe SSDs, the nvme-cli tool provides specific commands to retrieve detailed information and health status.

1. Install `nvme-cli`

Install the nvme-cli package using the appropriate command for your distribution:

Debian/Ubuntu:


sudo apt-get update
sudo apt-get install nvme-cli

Fedora:
```
sudo dnf install nvme-cli
```
Arch Linux:
```
sudo pacman -S nvme-cli
```

2. Check NVMe SSD Health

To check the health of an NVMe SSD, use:


sudo nvme smart-log /dev/nvme0n1

This command provides detailed health information specific to NVMe drives, including temperature, available spare, data units read/written, and more.

3. Detailed NVMe Information

For detailed device information, use:


sudo nvme id-ctrl /dev/nvme0n1

This command will output the controller information, giving you a deeper insight into your NVMe SSD.

Conclusion

Monitoring the health and status of your SSD in Linux is straightforward with tools like smartctl and nvme-cli. Regular checks can help you preemptively identify potential issues and maintain optimal performance. By following the steps outlined in this guide, you can ensure that your SSD remains in good health, prolonging its lifespan and reliability.

Stay proactive about your SSD's health, and you'll enjoy a more stable and efficient computing experience.

Simplify Your Firefox Migration Process: Copy .mozilla Folder

2024-05-12T18:08:59+00:00

Effortless Firefox Migration: How to Seamlessly Transfer Your Profile to a New Linux Install or Another Computer

Introduction: Migrating to a new Linux installation or another computer can be a daunting task, especially when it comes to preserving your Firefox settings, bookmarks, and passwords. However, there's a simple solution that can save you time and effort: copying the .mozilla folder in your home directory. In this article, we'll explore how you can effortlessly transfer your Firefox profile to ensure a seamless browsing experience on your new system.

Step 1: Locate Your Firefox Profile
The Firefox profile contains all your personal settings, bookmarks, history, extensions, and saved passwords. By default, this profile is stored in a hidden folder named .mozilla in your home directory. To locate it, open your file manager and enable the option to show hidden files. You should see the .mozilla folder in your home directory.

Step 2: Copy the .mozilla Folder
Once you've located the .mozilla folder, simply copy it to an external storage device or transfer it over the network to your new Linux installation or another computer. You can do this using the command line or a graphical file manager, depending on your preference.

If you're using the command line, you can use the following command to copy the .mozilla folder to an external drive:

cp -r ~/.mozilla /path/to/external/drive

Replace "/path/to/external/drive" with the actual path to your external drive.

Step 3: Paste the .mozilla Folder
After copying the .mozilla folder, navigate to your new Linux installation or another computer and paste the folder into your home directory. Again, make sure to show hidden files in your file manager to see the .mozilla folder.

Step 4: Launch Firefox
Once you've pasted the .mozilla folder into your home directory, you're ready to launch Firefox. When you open Firefox on your new system, it will automatically detect the transferred profile and load all your settings, bookmarks, history, extensions, and saved passwords.

Step 5: Verify Your Settings
After launching Firefox, take a moment to verify that all your settings, bookmarks, passwords, and extensions have been successfully transferred. You should see everything exactly as it was on your previous system.

Conclusion: Transferring your Firefox profile to a new Linux installation or another computer doesn't have to be a complicated process. By simply copying the .mozilla folder from your home directory, you can ensure that all your settings, bookmarks, passwords, and extensions are seamlessly transferred to your new system. So the next time you're setting up a new Linux installation or migrating to another computer, remember this quick and easy method for preserving your Firefox profile.

The Top Linux Distros for College Students

2024-05-11T21:30:21+00:00

The Top Linux Distros for College Students: A Comprehensive Guide

Ubuntu

Ubuntu is often hailed as one of the most user-friendly Linux distributions, making it an excellent choice for students new to the Linux ecosystem. Its extensive software library, combined with a user-friendly interface, ensures that students can easily find and install the tools they need for their coursework. Ubuntu's LTS (Long Term Support) releases provide stability and reliability, making it a dependable companion throughout your college journey.

Fedora

For students who crave the latest software and technologies, Fedora is an ideal choice. Known for its focus on innovation, Fedora offers cutting-edge features while maintaining a high level of stability. With a vibrant community and extensive documentation, Fedora is well-suited for students who want to stay at the forefront of technology.

Debian

Debian prides itself on stability and reliability, making it a solid choice for college students seeking a dependable operating system. With its vast repository of software packages, Debian provides access to a wide range of tools and applications for academic and personal use. Ideal for students interested in exploring the inner workings of Linux systems, Debian offers a rich learning experience alongside its robust performance.

Linux Mint

Linux Mint is renowned for its user-friendly interface, reminiscent of traditional desktop environments like Windows. With a focus on simplicity and ease of use, Linux Mint provides a seamless transition for students migrating from other operating systems. Its stability, combined with a rich selection of pre-installed software, ensures that students can focus on their studies without worrying about technical hurdles.

Manjaro

Based on Arch Linux, Manjaro offers a balance between cutting-edge software and system stability. With access to the Arch User Repository (AUR), Manjaro provides a vast selection of software packages for students with diverse interests and needs. Its flexibility and customization options make it an attractive choice for students who want to tailor their operating system to suit their preferences.

Pop!_OS

Developed by System76, Pop!_OS is designed with developers and power users in mind. Featuring a minimalist design and productivity-focused features like tiling window management, Pop!_OS enhances efficiency and workflow management for college students. With enhanced gaming support, it caters to students looking to strike a balance between work and play.

Elementary OS

Combining elegance with simplicity, Elementary OS offers a visually stunning desktop environment that appeals to students with a penchant for design aesthetics. Its lightweight system requirements make it suitable for older hardware, ensuring smooth performance even on low-end laptops. With the AppCenter for easy software installation, Elementary OS provides a hassle-free experience for college students.

Conclusion

Choosing the right Linux distribution can significantly impact your college experience, empowering you with the tools and resources you need to succeed academically and professionally. Whether you prioritize stability, cutting-edge technology, or user-friendly design, there's a Linux distro tailored to meet your needs. Experiment with different distributions, explore their features, and discover the one that resonates with you. With Linux, the possibilities are endless, and your college journey awaits with open arms.

Rsync Command: The Ideal and Reliable Way to Copy Large Files

2024-05-04T18:37:45+00:00

Introduction

When transferring files to my Android phone or many of my external hard drives I never use the file manager nor do I use "cp" command, I noticed that with file managers the computer actually slows down and sometimes the file manager becomes non resposnive with large files. I always use rsync command.

And it has been a life saver and reliable, when copying files to a remote server over the network even with network interruptions and low netowrk connection

What is Rsync?

Rsync is a command-line utility that synchronizes files and directories between two locations while minimizing data transfer by only copying the differences between them. This mechanism makes Rsync incredibly efficient, particularly for large files where transferring the entire file each time is impractical. Its cross-platform support ensures seamless operation across Linux, macOS, and Windows systems.

Benefits of Using Rsync

Rsync offers several advantages for large file copying:

•Efficiency: Rsync's delta-transfer algorithm ensures that only the portions of files that have changed are transferred, reducing bandwidth usage.

•Reliability: Rsync's ability to resume interrupted transfers and handle network disruptions makes it a dependable choice for mission-critical operations.

•Versatility: Whether you're copying files over a network or to/from external devices, Rsync's adaptability shines through, providing consistent performance across various scenarios.

Real-World Examples Using Rsync

Example 1: Copying Large Files Over a Network:

Whenever I want to copy files to my website server I use the following command:



sshpass -p "mypassword" \
    rsync -avPh --bwlimit=1000 --timeout=120 \
    --exclude '__pycache__' \
    -e "ssh -oHostKeyAlgorithms=+ssh-dss  -p<portnumber> " "local/directory/or/file" myusername@myserver.com:/path/to/my/remote/directory

And it has been a life saver and reliable, even with network interruptions and low netowrk connection

Example 2: Copying Large Files to/from External Devices

Transferring media files to my Android phone via MTP or simply to an external drive can be unreliable with conventional methods. Rsync offers a robust solution, ensuring uninterrupted transfers even in the event of interruptions or connectivity issues.

•Basic Usage: Use the following syntax to copy files:

rsync [options] source destination

        

rsync -ahrS --progress /path/to/source/  /path/to/destination
# or simply navigate to destination and
rsync -ahrS --progress /path/to/source/  .  # notice the dot ie current directory

•Advanced Options: You can use additional options like '-avz' for archiving and compressing data, '-P' for progress updates, '--partial' for resuming interrupted transfers, --exclude '*.djvu' to exclude files with the .djvu extension, and '--max-size=53m' to limit the transfer of files smaller than 53 megabytes. the last two are especially usefull when synchronizing(copying=) a directory

Best Practices

•Optimize Performance: Experiment with compression and other options to maximize transfer speeds, especially over slower connections.

•Secure Transfers: Use SSH for secure data transfers, safeguarding your files during transit.

•Selective Copying: Leverage Rsync's options to exclude unnecessary files or directories, streamlining the copying process.

Conclusion

In the realm of large file copying, Rsync stands out as a beacon of reliability and efficiency. Whether you're synchronizing files over a network or transferring data to/from external devices, Rsync's prowess remains unmatched. By integrating Rsync into your workflow, you can streamline your file copying processes, ensuring swift and dependable transfers every time.

Discover Feh Image Viewer's Montage Mode: Effortlessly Create Stunning Image Collages

2024-05-03T17:46:48+00:00

Introduction:

Discover the power of Feh Image Viewer, a versatile and lightweight tool designed for seamless image viewing, management, and presentation. With its minimalist design and command-line interface, Feh offers a streamlined experience suitable for both casual users and professionals alike. In this comprehensive guide, we'll explore how to harness the full potential of Feh Image Viewer, including its standout feature: the robust montage mode for effortlessly creating visually captivating image collages. Additionally, we'll walk you through the installation process on various Linux distributions, enabling you to unlock Feh's powerful functionality with ease and efficiency.

Installation

    

# in Debian and Ubuntu based distros:
sudo apt install feh
# Arch linux:
sudo pacman -S feh
# fedora
sudo dnf install feh

Feh Image Viewer

Viewing Individual Images:
With Feh, viewing individual images is as simple as running the command feh /path/to/image. This straightforward command allows users to open and view images quickly without any unnecessary overhead. Feh's minimalist interface ensures that the focus remains on the image itself, providing a distraction-free viewing experience.

Browsing Image Directories:
Feh also excels at handling directories of images. By passing a directory path as an argument (feh /path/to/directory), Feh launches in a mode where it displays all images within that directory sequentially. Users can navigate through the images using keyboard shortcuts, allowing for efficient browsing of image collections without the need for a complex graphical user interface.

Montage Mode:
Feh's montage mode is a powerful feature that enables users to create visual collages or montages of images. By executing a command like this:

    

feh --index-info "%u\n" \       # Set format for image information
    -x -m -W 1920 -H 1080 \     # Display images in index mode with montage layout,
                        # set width and height of montage window
    -E 180 -y 180  \            # Set height and width of thumbnails
    -f "$image_list" \          # Specify file containing list of images
    -o "montage_output.png" \   # Save the generated montage as PNG
    2> /dev/null             # Redirect error messages to /dev/null

Feh Montage

Users can arrange images in a grid layout, specifying parameters such as width, height, and spacing. This mode is particularly useful for comparing multiple images side by side or creating thumbnails for image galleries.

Feh Desktop Backgrounder

Setting Desktop Background:
Feh offers seamless integration with desktop environments by allowing users to set images as desktop backgrounds directly from the command line. The command :



feh --image-bg bg_color --bg-max "/path/to/image"

sets the specified image as the desktop background, adjusting its size and position to fit the screen resolution. Users can also customize the background color (bg_color) and choose between different scaling options (--bg-max) to achieve the desired visual effect.

In summary, Feh Image Viewer offers a versatile set of features for both image viewing and desktop background management. Whether you need a lightweight and efficient tool for browsing images or a flexible solution for customizing your desktop environment, Feh provides the necessary tools to meet your needs with simplicity and reliability.

Access Local Websites: Linux to Windows in VirtualBox

2024-04-30T20:56:51+00:00

How to Access a Local Website from a Linux Host Machine to a Windows Guest Machine in VirtualBox

If you're running a Windows virtual machine (VM) inside VirtualBox on your Linux host, you might want to access a local website or service hosted on the guest machine. In this guide, we'll walk through the steps to set up communication between your Linux host and Windows guest using a host-only network.

Prerequisites

VirtualBox: Ensure that you have VirtualBox installed on your Linux host machine.

Windows Guest VM: Set up a Windows virtual machine in VirtualBox.

Steps:

1. Create a Host-Only Network in VirtualBox:

• Open VirtualBox and go to File > Host Network Manager.

VirtualBox Network Manager

• In the Host-Only Networks tab, click Create. A host-only network will be created with the default name "vboxnet0".

Host-Only Network Creation

<p>&#8226; By default, it will have an IPv4 prefix of <code>192.168.56.1/24</code> and DHCP enabled.</p>

2. Configure the Virtual Machine Settings:

• Open the settings for your Windows guest virtual machine.

• Keep the first network adapter (usually NAT) as it is.

• Enable the second network adapter and select Attached to: "Host-Only Adapter".

• Choose the network name "vboxnet0" (the one you created in step 1).

Host-Only Network Adapter

3. Start Your Virtual Machine:

• Now, whenever you run your Windows guest virtual machine, it will be connected to the host-only network.

• On the host machine (Linux), you'll find a local network for communication between the host and guest machines. in my case I got something like this

    

$ ip a | grep -oP '(?<=inet |addr:)(?:\d+\.){3}\d+'
127.0.0.1   # loopback adress
192.168.1.5 # my machine local IP adress in my Local network
192.168.56.1    # this is the IP address of the host-only network
192.168.56.101  # my machine IP adress in the host-only network

If I have a website running in my Linux (host) machine on port 8081 then I can access it in the guest VM like this 192.168.56.1:8081 or 192.168.56.101:8081 or 192.168.1.5:8081 when I am connected to a local network

Automated Backup Solutions: Safeguarding Your Daily Work

2024-04-16T22:19:46+00:00

In the digital age, where the bulk of our work and personal documents exist in electronic format, ensuring their safety and accessibility is paramount. Imagine investing hours into crafting a crucial report, a research paper, or a personal project only to lose it due to technical glitches, accidental deletions, or hardware failures. To prevent such nightmares, it's essential to establish a robust backup system. In this guide, we'll explore how to backup your important documents, focusing particularly on files you interact with daily, such as ongoing projects or works-in-progress.

Understanding the Importance of Regular Backups

Before delving into the specifics of backup methods, let's underscore why regular backups are indispensable:

•Data Loss Prevention: Accidents happen. Whether it's a power outage, a software crash, or human error, the risk of losing valuable data is ever-present.

•Protection Against Hardware Failure: Hard drives can fail unexpectedly, resulting in permanent data loss. Backing up your files ensures that even if your primary storage device malfunctions, your data remains intact.

•Version Control: When working on documents that undergo frequent revisions, maintaining a history of changes allows you to revert to earlier versions if necessary.

Implementing a Backup Strategy

•Identify Critical Files: Begin by identifying the files and folders that are indispensable to you. This includes documents, presentations, spreadsheets, and any other data you interact with regularly.

•Select a Backup Method: There are various backup methods available, ranging from manual backups to automated solutions. Choose a method that aligns with your workflow and provides the level of redundancy you require.

•Automate the Process: Automating backups ensures consistency and minimizes the risk of human error. Utilize tools like cron jobs (for Unix-like systems) or task schedulers (for Windows) to schedule regular backups at convenient intervals.

•Utilize Versioning Systems: Version control systems such as Git are invaluable for managing projects involving code or text-based documents. They track changes over time, allowing you to revert to previous versions effortlessly.

Example Backup Script for Daily Use

If you're working on documents regularly and want a straightforward backup solution, consider implementing a script similar to the following:



#!/usr/bin/env bash

# Define backup directory
backup_dir="$HOME/backups"

# Create backup directory if it doesn't exist
mkdir -p "$backup_dir"

# Get current date and time
timestamp=$(date +%Y-%m-%d_%H-%M-%S)

# Get current directory name
current_dir=$(basename "$(pwd)")

# Create backup filename with directory name
backup_file="$backup_dir/${current_dir}_backup_$timestamp.tar.gz"

# Archive current directory and compress it
tar -czf "$backup_file" .

echo "Backup created: $backup_file"

This script creates a compressed archive of the current directory and saves it in a designated backup directory. You can then schedule it to run daily using a cron job, ensuring that your files are backed up regularly without manual intervention.

Conclusion

Protecting your important documents through regular backups is a simple yet crucial practice that can save you from potential disasters. By implementing a robust backup strategy and leveraging automation where possible, you can safeguard your work and enjoy peace of mind knowing that your data is secure and accessible whenever you need it. Remember, when it comes to backups, it's better to be safe than sorry.

Nmap: A Deep Dive into Network Security Auditing

2024-04-16T21:53:46+00:00

In today's interconnected digital landscape, understanding the intricacies of network security is paramount. Whether you're a seasoned cybersecurity professional or an enthusiastic novice, having the right tools at your disposal is crucial. Among these tools, Nmap stands out as a cornerstone for network exploration and security auditing. In this article, we'll delve into the depths of Nmap, exploring its features, applications, and best practices.

What is Nmap?

Nmap, short for Network Mapper, is an open-source tool designed for network exploration and security auditing. Developed by Gordon Lyon, commonly known by his pseudonym "Fyodor," Nmap has evolved over the years into a robust and versatile utility. It operates by sending packets to target hosts and analyzing their responses to provide valuable information about the network's topology, services, operating systems, and potential vulnerabilities.

Key Features of Nmap:

Port Scanning

One of Nmap's primary functions is port scanning. It allows users to discover open ports on target systems, providing insights into the services running on those ports and potential entry points for attackers.

nmap -p 1-100 192.168.1.1

Host Discovery

Nmap facilitates the discovery of hosts within a specified range of IP addresses. By sending ICMP echo requests, TCP SYN, ACK, or UDP probes, it identifies active hosts on the network.

nmap -sn 192.168.1.0/24

Service Version Detection

Nmap can determine the versions of services running on open ports, aiding in vulnerability assessment and patch management.

nmap -sV 192.168.1.1

OS Fingerprinting

Through a series of probing techniques, Nmap can attempt to identify the operating systems of target hosts based on their responses to network packets.

nmap -O 192.168.1.1

Scripting Engine

Nmap's scripting engine (NSE) allows users to automate and customize tasks, extending its functionality for specific purposes such as vulnerability scanning and network inventory.

Best Practices and Considerations:

Permission and Legality

Always ensure you have proper authorization before scanning networks. Unauthorized scanning could lead to legal repercussions.

Stealth and Discretion

Depending on the context, choose scan types that prioritize stealth to avoid detection by intrusion detection systems (IDS) or firewall logs.

Documentation

Document scan results meticulously, including dates, times, and specific configurations used. This information is invaluable for audits and future reference.

Regular Updates

Keep Nmap and its associated scripts updated to leverage the latest features and security enhancements.

Conclusion:

Nmap stands as a stalwart in the realm of network exploration and security auditing, empowering users with insights into network topology, services, and potential vulnerabilities. Its versatility, coupled with a rich set of features, makes it an indispensable tool for cybersecurity professionals worldwide. By understanding its capabilities and adhering to best practices, users can harness the power of Nmap to fortify their networks against potential threats and vulnerabilities.

Mastering Cron Jobs: A Step-by-Step Guide from Beginner to Advanced

2024-04-11T10:51:10+00:00

Introduction:

Cron jobs are an essential part of Unix-based operating systems, allowing users to schedule repetitive tasks to be executed automatically. These tasks can range from simple commands to more complex scripts. In this guide, we'll explore the fundamentals of cron jobs and explain various scheduling options using real-world examples.

1. What is a Cron Job?

A cron job is a time-based job scheduler in Unix-like operating systems. It enables users to schedule tasks to run periodically at fixed times, dates, or intervals without manual intervention.

2. Components of a Cron Job:

Field	Values	Meaning	Examples
Minute	0-59	The minute of the hour	* (every minute), */2 (every 2 minutes)
Hour	0-23	The hour of the day	* (every hour), 18 (6 PM), 0-23/2 (every 2 hours)
Day of the month	1-31	The day of the month	* (every day), */2 (every 2 days), 5 (5th day of the month)
Month	1-12 (or names)	The month of the year	* (every month), 1 (January), */2 (every 2 months), 5 (May)
Day of the week	0-7 (0 and 7 represent Sunday, or use names)	The day of the week	* (every day of the week), 1 (Monday), 0,6 (Sunday and Saturday)

3. Basic Cron Job Syntax:

* * * * * /path/to/command

The syntax consists of five fields separated by spaces. Each field represents a unit of time and specifies when the command should be executed.

4. Explaining Cron Job Fields:

In a cron expression, there are five fields separated by spaces. Each field represents a different unit of time and determines when the command will be executed. Here's an explanation of each field:

Minute: Represents the minute of the hour (0-59). For example, if you specify `30` in this field, the command will run at the 30th minute of every hour.
Hour: Represents the hour of the day (0-23). If you specify `3` in this field, the command will run at 3:00 AM.
Day of Month: Represents the day of the month (1-31). If you specify `1`, the command will run on the 1st day of every month.
Month: Represents the month of the year (1-12 or names). If you specify `3` or `March`, the command will run in March.
Day of Week: Represents the day of the week (0-7 or names, where 0 and 7 represent Sunday). If you specify `5` or `Friday`, the command will run on Fridays.

By combining these fields with specific values or wildcards (*), you can create precise schedules for your cron jobs.

5. Examples of Common Cron Jobs:

    

# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7)
# |  |  |  |  |
# *  *  *  *  *  /path/to/command to be executed
  0 18  *  *  *  /path/to/command    # every day at 18:00
 30 18  *  *  *  /path/to/command    # every day at 18:30
  0  0  1  *  *  /path/to/command    # every 1st of month (evey month)
  0  0  1  1  *  /path/to/command    # every 1 of month 1 (January) ie every year
  0  0  5  1  *  /path/to/command    # every 5th of month 1 (January) ie every year
  0  0  5  *  *  /path/to/command    # every 5th of every month

6. Other Symbols in Cron Expressions:

•Comma (,): Specifies a list of values within a field. Example: 0 0 1,15 * * /path/to/command (Runs on the 1st and 15th day of every month)

•Hyphen (-): Specifies a range of values within a field. Example: 0 9-17 * * * /path/to/command (Runs every hour from 9:00 AM to 5:00 PM)

•Slash (/): Specifies increments within a field. Example: */10 * * * * /path/to/command (Runs every 10 minutes)

7. More examples of Cron Jobs:

    

# More example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7)
# |  |  |  |  |
# *  *  *  *  *  /path/to/command to be executed
*/2  *  *  *  *  /path/to/command    # Every 2 Minutes
  5  0  *  *  *  $HOME/bin/daily.job >> $HOME/tmp/out 2>&1  # run five minutes after midnight, every day

 15 14  1  *  *     $HOME/bin/monthly   # run at 2:15pm on the first of every month
  0 22  *  * 1-5    /path/to/command  # run at 10 pm on weekdays, annoy Joe
23 0-23/2 * * *     echo "run 23 minutes after midn, 2am, 4am ..., everyday"
  5  4  *  * sun    echo "run at 5 after 4 every sunday"

  0  0  1  1  *   [[ $(date "+\%Y") == 2030 ]] &&/path/to/command1
  0  0  1  1  *   (( $(date "+\%Y") % 3 == 0  )) &&/path/to/command2
  0  0  1  1  *   (( $(date "+\%Y") % 3 == 1  )) &&/path/to/command3

command1 will run on the 2030-01-01T00:00:00
command2 will run every 3 years ( every year number multiple of 3) on the first of January at midnight, it will run on 2019, 2022, 2025, ... .
command3 does the same as command2 but has one year offset, i.e. 2020, 2023, 2026, ...

note: don't forget that you have to escape the -character (%) in your crontab file:

The "sixth" field (the rest of the line) specifies the command to be run. The entire command portion of the line, up to a newline or a "%" character, will be executed by /bin/sh or by the shell specified in the SHELL variable of the cronfile. A "%" character in the command, unless escaped with a backslash (\), will be changed into newline characters, and all data after the first % will be sent to the command as standard input.

— source: man 5 crontab

8. Adding Jobs with Crontab:

You can add new cron jobs using the crontab command. Follow these steps:

1 • Open the Crontab Editor: To edit your crontab file, enter the following command in your terminal:
crontab -e

2 • Add Your Cron Job: In the crontab editor, add a new line for your cron job. Each line represents a separate cron job.

3 • Save and Exit: After adding your cron job, save the changes and exit the crontab editor. The specific steps to save and exit depend on the text editor you're using.

4 • Once you've added your cron job, it will be saved and scheduled to run according to the specified schedule. You can verify that your cron job has been added by running crontab -l to list all cron jobs associated with your user account.

Remember to be cautious when editing the crontab file, as incorrect entries can lead to unexpected behavior or errors.

9. Conclusion:

In this guide, we've covered the fundamentals of cron jobs, including their purpose, syntax, and common scheduling options. Cron jobs are powerful tools for automating repetitive tasks in Unix-like operating systems, and understanding how to use them effectively can greatly enhance productivity.

By mastering the syntax and scheduling options of cron jobs, users can streamline their workflow and ensure that routine tasks are executed reliably and efficiently. With the examples provided in this guide, beginners can start leveraging cron jobs to automate tasks and save time.

Stay Tuned:

Stay tuned for more guides and tutorials.

Enhancing Quranic Study with a Command-Line Quran Search and Display Script

2024-04-08T23:32:18+00:00

Your browser does not support the video tag.

In the modern digital age, technology plays a significant role in facilitating various aspects of religious study and practice. Among the numerous religious texts revered by millions worldwide, the Quran holds a central position in Islam. To aid in the exploration and comprehension of this sacred scripture, a novel approach emerges—a command-line Quran search and display script. This article delves into the functionality, usage, and significance of such a tool in the context of Quranic study.

Understanding the Script

    

script_dir=$(dirname "$0")
file1="$script_dir/quran-simple-clean.txt"
file2="$script_dir/quran-uthmani.txt"
file3="$script_dir/chapters-simple.txt"
quran_text="$(paste -d'|' "$file1" "$file2" )"

# the command-line arguments
number1=$1
number2=$2
number3=$3

print_lines() {
chapter_name=$(sed -n "$2"p "$file3" )
echo "$1" | awk -F '|' -v num1="$2" -v num2="$3" -v num3="$4" -v chap="$chapter_name" \
    '{
        if ((num3 != "") && ($1 == num1) && ($2 >= num2) && ($2 <= num3)) {
       printf("(\033[1;31m %d %s\033[1;0m) %s\n",$5,chap,$6);
        } else if ((num2 != "") && (num3 == "") && ($1 == num1) && ($2 == num2)) {
       printf("(\033[1;31m %d %s\033[1;0m) %s\n",$5,chap,$6);
        } else if ((num2 == "") && (num3 == "") && ($1 == num1)) {
       printf("(\033[1;31m %d %s\033[1;0m) %s\n",$5,chap,$6);
        }
    }'
}

if [[ $1 == h ]] ; then
    echo "Usage:
$(basename "$0")
$(basename "$0")  g   open with uthmani Quran in gedit
$(basename "$0")  [sourah/chapter] [num1] [num2]"
    exit
fi

if [[ $1 == g ]] ; then
    nohup gedit "$file2" </dev/null >/dev/null 2>&1 &
    exit
fi

number='^[0-9]+$'
if [[ "$1" =~ $number ]] ; then
    if [ -z "$number2" ]; then
        text=$(print_lines "$quran_text" "$number1")
    elif [[ -z "$number3" ]]; then
        text=$(print_lines "$quran_text" "$number1" "$number2")
    else
        text=$(print_lines "$quran_text" "$number1" "$number2" "$number3")
    fi
    if [[ $@ == *g* ]]
    then
        echo "$text" > /tmp/quran_result
        nohup gedit "/tmp/quran_result" </dev/null >/dev/null 2>&1 &
    else
        echo "$text"
    fi
else
    xkb-switch -s ara
    pkill -RTMIN+12 i3blocks
    pattern=$( zenity --entry --text="Search Holy Quran:" \
        --title="search Holy Quran" --width=500 --timeout=30)
    xkb-switch -s fr
    pkill -RTMIN+12 i3blocks

    if [[ -n $pattern ]] ; then
       results="$(echo "$quran_text" | grep --color=always "$pattern")"

       if [[ -n $results ]]
           then resuls_count=$(echo "$results" | wc -l)
           else resuls_count=0
       fi
       echo "searching : $pattern"
       echo "================================"
       echo "$resuls_count found"
       echo "================================"
       echo "$results" > /tmp/quran_result
       awk -F'|' '
        NR==FNR {chap[FNR]=$0; next}
        {printf("(\033[1;31m %d %s\033[1;0m) %s\n",$5,chap[$1],$6);}
       ' "$file3"  /tmp/quran_result
    fi
fi

The command-line Quran search and display script is a versatile tool designed to streamline the process of accessing and studying verses from the Quran. Written in the Bash scripting language, this script leverages a combination of Unix commands such as 'sed', 'awk', 'paste', 'zenity', and 'xkb-switch' to provide users with a seamless experience.

Features and Usage

Your browser does not support the video tag.

The script offers several features tailored to cater to the diverse needs of users engaging with the Quran:

• Interactive Search: Users can initiate an interactive search prompt, enabling them to search for specific keywords or phrases within the Quranic text.

• Verse Display: By providing chapter and verse numbers as command-line arguments, users can display specific verses from the Quran.

• Visual Enhancement: The script incorporates color-coded output for improved readability, enhancing the user experience during verse display.

• Integration with Text Editor: Users can seamlessly open the Uthmani version of the Quran in the 'gedit' text editor directly from the command line.

Significance in Quranic Study

The command-line Quran search and display script serves as a valuable tool for both scholars and enthusiasts alike:

• Accessibility: By offering a command-line interface, the script provides accessibility to users across various platforms without the need for complex software installations.

• Efficiency: With its streamlined search and display capabilities, the script enables users to quickly retrieve and study specific verses, enhancing the efficiency of Quranic study sessions.

• Customization: The script's modular design allows for easy customization and adaptation to specific study preferences or requirements, catering to the diverse needs of users.

GitHub Repository

The script along with the Quran text files can be found in the GitHub repository: https://github.com/neoMOSAID/quran-search. Users can access, contribute, and provide feedback on the script and its associated resources.

Conclusion

In the realm of Quranic study, the command-line Quran search and display script emerges as a versatile and efficient tool, empowering users to delve deeper into the sacred text with ease and convenience. Its integration of modern technology with traditional scholarship exemplifies the harmonious intersection of faith and innovation, facilitating a richer and more immersive Quranic study experience for all.

How to Use the date Command in Linux: Complete Guide and Examples

2024-04-07T20:03:26+00:00

The date command in Linux is a versatile tool used for displaying and formatting date and time information. Whether you need to display the current date and time, manipulate dates, or format them in a specific way, date has you covered. In this tutorial, we'll explore various use cases and formats of the date command to help you become proficient in its usage.

Displaying the Current Date and Time

To display the current date and time, simply run the date command without any arguments:



date

Output:

Wed Apr  6 22:05:24 UTC 2024

Formatting Date and Time

Basic Formatting

You can format the output of date using format specifiers. For example, to display the date in YYYY-MM-DD format:



date '+%Y-%m-%d'

Output:

2024-04-06

Customized Formats

You can customize the output further by combining different format specifiers. For instance:



date '+%A, %B %d, %Y - %H:%M:%S'

Output:

Wednesday, April 06, 2024 - 22:05:24

Manipulating Dates

Adding or Subtracting Days

To manipulate dates by adding or subtracting days, use the --date option:



# Add 1 day to the current date
date --date "+1 days"

Output:

Thu Apr  7 22:05:24 UTC 2024



# Subtract 307 days from the current date
date -d '-307 days'

Output:

Tue May  3 22:05:24 UTC 2023

Displaying Dates Relative to Today

You can display dates relative to today using expressions like "today" or "last Monday":



# Display the date of the last Monday
date -d 'last Monday'

Output:

Mon Apr  3 00:00:00 UTC 2024

Localization

The LC_ALL environment variable can be used to specify the locale for date formatting:



# Display date in Arabic locale
LC_ALL=ar_MA.utf8 date '+%A %d %h %Y, %H:%M'

Output:

الأربعاء 07 إبريل 2024, 22:05

Conclusion

The date command in Linux offers a wide range of functionalities for displaying, formatting, and manipulating dates and times. By mastering its various options and format specifiers, you can efficiently handle date-related tasks in your shell scripts and command-line operations. Experiment with different combinations of options and formats to suit your specific requirements.

Mastering grep in Linux: Advanced Tips and Tricks for Text Pattern Searching

2024-04-05T15:43:45+00:00

Grep, short for "global regular expression print," is a powerful command-line utility in Linux used for searching text patterns in files. While it's commonly known for its basic usage, such as finding a word or phrase in a file, grep offers a plethora of advanced features and techniques that can significantly enhance its utility. In this article, we'll delve into some advanced uses of the grep command in Linux.

1. Searching Multiple Files

By default, grep searches only within a single file. However, you can instruct grep to search across multiple files simultaneously by specifying a wildcard or a list of filenames.



grep "pattern" file1.txt file2.txt file3.txt

Or using a wildcard:



grep "pattern" *.txt

2. Recursive Searching

To search for a pattern in all files within a directory and its subdirectories, you can use the -r or --recursive option.



grep -r "pattern" /path/to/directory

3. Inverting Match

Sometimes you may want to find lines that do not match a particular pattern. You can achieve this by using the -v or --invert-match option.



grep -v "pattern" file.txt

4. Displaying Line Numbers

To display line numbers along with matching lines, use the -n or --line-number option.



grep -n "pattern" file.txt

5. Case Insensitive Search

By default, grep performs case-sensitive searches. To ignore case distinctions in both the pattern and the input files, use the -i or --ignore-case option.



grep -i "pattern" file.txt

6. Using Regular Expressions

Grep supports powerful regular expressions for pattern matching. Regular expressions allow you to define complex search patterns. For example, to match lines containing either "word1" or "word2," you can use the | (pipe) operator.



grep "word1\|word2" file.txt

7. Counting Matches

To count the number of lines containing a match rather than displaying the lines themselves, use the -c or --count option.



grep -c "pattern" file.txt

8. Recursive Inclusion and Exclusion

When using recursive searching, you may want to include or exclude certain files or directories. You can achieve this using the --include and --exclude options.



grep -r --include "*.txt" "pattern" /path/to/directory

9. Displaying Context

Sometimes it's useful to display surrounding lines along with the matching lines. You can do this using the -A, -B, or -C options to display lines after, before, or around the matching lines, respectively.



grep -A 2 -B 2 "pattern" file.txt

10. Output Formatting

You can customize the output format of grep using various options such as -o to only display the matching part of the line, -l to list filenames with matches, and -H to always print filenames with output.



grep -o "pattern" file.txt
grep -l "pattern" *.txt
grep -H "pattern" file1.txt file2.txt

Conclusion

The grep command in Linux is a versatile tool for searching and manipulating text data. By mastering its advanced features and techniques, you can efficiently extract information from files, directories, and even entire filesystems. Experiment with these advanced grep commands to streamline your text processing workflows and become more proficient at handling textual data in the Linux environment.

Mastering Cut Command in Linux: Advanced Tips and Tricks

2024-04-04T21:50:02+00:00

The Cut command in Linux is a powerful tool for slicing and dicing text files and streams with ease. While its basic functionality allows users to extract specific columns or fields from input, mastering its advanced features can significantly enhance your efficiency and productivity. In this article, we'll delve into the advanced uses of the Cut command, showcasing its versatility and potential.

Basic Syntax:

The basic syntax of the Cut command is as follows:



cut OPTION... [FILE]...

Sample Data File:

Let's consider a CSV file named data.csv with the following content:



Name, Age, Gender, Occupation
John, 30, Male, Engineer
Alice, 25, Female, Scientist
Bob, 35, Male, Doctor

1. Delimiter Specification:

By default, Cut uses the tab character as the field delimiter. However, it can be customized to work with any delimiter using the -d option. For instance, to specify a comma (,) as the delimiter, you can use:



cut -d',' -f1,2 data.csv

This command extracts the first and second fields from data.csv.

2. Selecting Fields:

The -f option allows you to specify the fields you want to extract. You can select individual fields or ranges separated by a hyphen. For example:



cut -d',' -f1,3-4 data.csv

This command extracts the first field and fields 3 to 4 from the input.

3. Outputting Fields with Delimiters:

To retain the delimiters along with the selected fields in the output, you can use the -c option. For example:



cut -d',' -f1,3-4 -c data.csv

This command retains the delimiters and extracts the specified fields.

4. Character Ranges:

In addition to specifying fields, Cut can also extract specific character ranges using the -c option. For example:



cut -c1-10 data.csv

This command extracts the first 10 characters from each line of the input.

5. Suppressing Output:

You can suppress the output for lines that do not contain any delimiters using the -s option. For instance:



cut -d',' -f2 --complement data.csv

This command suppresses lines without delimiters and extracts all fields except the second field.

6. Outputting Complementary Fields:

The --complement option complements the fields selected, i.e., it outputs all fields except those specified. For example:



cut -d',' --complement -f3 data.csv

This command outputs all fields except the third field.

7. Multiple Delimiters:

Cut also supports multiple delimiters using the -d option. For instance:



cut -d'[:;,]' -f1-3 data.csv

This command extracts fields using either a colon (:), semicolon (;), or comma (,) as the delimiter.

Conclusion:

The Cut command in Linux offers a wide range of features for text manipulation, making it an indispensable tool for data processing tasks. By mastering its advanced options, you can efficiently extract, manipulate, and analyze text data according to your specific requirements. Experiment with these advanced features to streamline your workflow and unlock the full potential of the Cut command.

Mounting Android Phones in Linux Made Easy

2024-03-23T17:21:31+00:00

In the realm of technology, interoperability between different platforms has become increasingly important. For Linux users, accessing and managing files on an Android phone was once a cumbersome task, often requiring third-party software or complex configurations. However, with the advancements in the Linux ecosystem, mounting an Android phone has become simpler than ever. In this guide, we'll walk you through the steps to effortlessly mount your Android phone in a Linux environment.

Modern Android devices typically use the Media Transfer Protocol (MTP) to facilitate file transfers between the device and a computer. MTP is a standardized protocol that allows the transfer of files and metadata between devices. Unlike traditional USB Mass Storage, MTP provides a more flexible and secure method for accessing files on Android devices.

To interact with Android devices using MTP on a Linux system, we rely on the gvfs-mtp package. gvfs-mtp is part of the GNOME Virtual File System (gvfs) framework, which provides a high-level API for accessing and manipulating files and devices. gvfs-mtp specifically enables MTP support within the GNOME environment, allowing seamless integration of Android devices with Linux desktops.

Installing gvfs-mtp

To begin, you'll need to ensure that your Linux system has the necessary packages installed to facilitate the mounting process. Depending on your Linux distribution, you can use package managers to install the required components.

Arch-based Distributions (e.g., Arch Linux)



pacman -S mtpfs gvfs-mtp

Debian/Ubuntu-based Distributions



apt install gvfs-mtp

Connecting Your Android Phone

Once you've installed the necessary packages, connect your Android phone to your Linux machine using a USB cable. After connecting, it's essential to confirm whether the connection was successful and identify the device.



lsusb | grep -i smartphone

This command will display the USB details of the connected smartphone, confirming the connection. Something like this:

    

Bus 001 Device 008: ID 12d1:107e Huawei Technologies Co., Ltd. P10 smartphone

Mounting Your Android Phone

After confirming the connection, it's time to mount your Android phone. First, you need to find the root path of your device using the following command:



gio mount -li | grep activation_root

This command will display the activation root of your device, providing you with the necessary information to mount it. it will be like this

    

activation_root=mtp://HUAWEI_JNY-LX1_AUDUT20901002554/

Now, let's mount the device using the obtained root path:



gio mount "mtp://HUAWEI_JNY-LX1_AUDUT20901002554/"

Alternatively, you can also use the Bus and Device Number obtained from the lsusb output to mount your device:



gio mount "mtp://[usb:001,008]/"

Accessing Mounted Device

Once the device is mounted, you can access it like any other file system. Navigate to the following directory to view the mounted device:



ls -l /run/user/1000/gvfs

Unmounting Your Android Phone

After completing the necessary operations, it's essential to unmount your Android phone properly to ensure data integrity and safe disconnection.



gio mount -u "mtp://HUAWEI_JNY-LX1_AUDUT20901002554/"

Conclusion

Mounting an Android phone in a Linux environment doesn't have to be a daunting task. With the right tools and commands, you can seamlessly access and manage files on your device. By following the steps outlined in this guide, you can effortlessly mount your Android phone in Linux, enhancing your productivity and workflow.

How To Install Tor Browser And Open Onion Links

2024-03-23T16:38:41+00:00

Navigating the Web Anonymously: A Guide to Installing Tor Browser

In an age where online privacy is increasingly important, users are turning to tools like the Tor Browser to browse the internet anonymously and securely. Whether you're concerned about protecting your personal information or accessing content blocked in your region, Tor Browser provides a solution. In this guide, we'll walk you through the steps to install Tor Browser on your device.

What is Tor Browser?

Tor Browser is a web browser that enables users to browse the internet anonymously by routing their connection through a network of volunteer-operated servers. This network, known as the Tor network, encrypts and redirects internet traffic, making it difficult for anyone to track a user's online activity, including their browsing habits and location.

Step 1: Downloading Tor Browser

Visit the official Tor Project website at https://www.torproject.org/.
Navigate to the "Download" section.
Select your operating system (Windows, macOS, Linux, Android) and click on the corresponding download link.

Step 2: Installing Tor Browser

For Windows:

Once the download is complete, locate the downloaded file (usually in your Downloads folder) and double-click on it to run the installer.
Follow the on-screen instructions to install Tor Browser on your system.
After the installation is complete, launch Tor Browser by double-clicking its icon.

For macOS:

Locate the downloaded .dmg file and double-click on it to mount the disk image.
Drag the Tor Browser icon to your Applications folder to install it.
Once installed, you can launch Tor Browser from your Applications folder or by searching for it in Spotlight.

For Linux:

Open a terminal window.
Navigate to the directory where the downloaded file is located.
Extract the downloaded file using the following command: `tar -xvf tor-browser-linux64-*.tar.xz` (replace `tor-browser-linux64-*.tar.xz` with the actual filename).
Once extracted, navigate to the newly created directory (`tor-browser_en-US`) and run the `start-tor-browser.desktop` file to launch Tor Browser.
In Arch linux, I installed it from AUR "Arch User Repository" like this with the command:



yay -S tor-browser

For Android:

Download Tor Browser from the Google Play Store or the official Tor Project website.
Follow the on-screen instructions to install the app on your device.
Once installed, open the app and start browsing anonymously.

Step 3: Configuring Tor Browser

After launching Tor Browser, you'll be presented with the Tor Network Settings window. Here, you can choose whether to connect directly to the Tor network or configure proxy settings if you're using a network that requires one.

Step 4: Using Tor Browser

Once you've configured the network settings, you can start using Tor Browser like any other web browser. Simply enter a URL into the address bar, and Tor Browser will route your connection through the Tor network, protecting your anonymity and privacy online.

Enhancing Tor Browser Functionality with Custom Shell Scripts

In addition to the standard installation process, users can further optimize their Tor Browser experience by leveraging custom shell scripts like the ttor function provided below. This script allows users to open Tor Browser with the impossible to remember onion links directly from the command line.

    


function ttor {
    [[ "$1" == k ]] && {
        kill -9 "$(cat /tmp/ttor_pid )"
        return
    }
    if [[ -t 0 ]]
        then aa="$@"
        else aa=$( cat )
    fi
    links="about:newtab  "
    links+="https://duckduckgogg42xjoc72x3sjasowoarfbgcmvfimaftt6twagswzczad.onion/  "  #duckduckgo
    #links+="www.thepiratebay.org  "
    links+="http://piratebayo3klnzokct3wt5yyxb2vpebbuyjl7m623iaxmqhsd52coid.onion/  "   #thepiratebay
    links+="http://jaz45aabn5vkemy4jkg4mi4syheisqn2wn2n4fsuitpccdackjwxplad.onion/  "   #onionlinks
    links+="http://xsglq2kdl72b2wmtn5b2b7lodjmemnmcct37owlz5inrhzvyfdnryqid.onion/  "      #wiki
    links+="http://bj5hp4onm4tvpdb5rzf4zsbwoons67jnastvuxefe4s3v7kupjhgh6qd.onion/  "      #wiki
    [[ -n "$aa" ]] && links+="$aa"
    tor-browser --detach $( echo "${links[@]}" ) &
    pid=$!
    echo $pid
    echo "$pid"  >| "/tmp/ttor_pid"
}

How to Use the `ttor` Function:

To use the ttor function, you can follow these steps:

Adding the Function to Configuration Files:
- Add the ttor function to your .bashrc, .zshrc, or any other shell configuration file. You can do this by opening the file in a text editor and pasting the function definition at the end of the file.
Sourcing the Configuration File:
- After adding the function to the configuration file, save the changes and close the editor. Then, reload the configuration file in your terminal session by running the command source ~/.bashrc (or source ~/.zshrc for Zsh users).
Using the ttor Function:
- To open Tor Browser with the default links, simply type ttor in your terminal.
- To open Tor Browser with additional links, pass them as arguments to the function, like ttor example.com.
- To terminate the Tor Browser process, use ttor k.

Tor brower with onion sites

Alternatively, you can save the function as a separate shell script file and make it executable. Then, you can run the shell script whenever you need to open Tor Browser with specific links.

Utilizing such custom scripts not only streamlines the process of accessing Tor Browser but also provides users with added flexibility in managing their browsing sessions. However, users should exercise caution and ensure that they trust the sources of such scripts to maintain the integrity and security of their online activities.

Conclusion

Installing Tor Browser is a straightforward process that allows you to browse the internet anonymously and securely. By following the steps outlined in this guide, you can take control of your online privacy and access the web without fear of surveillance or tracking. So why wait? Install Tor Browser today and start browsing the web with peace of mind.

Linux Basics for Hackers

2024-03-15T14:34:00+00:00

In the ever-evolving landscape of cybersecurity, one tool stands out as indispensable: Linux. And for those aspiring to delve into the realms of ethical hacking and penetration testing, mastering Linux is not just advantageous; it's essential. Enter "Linux Basics for Hackers" by OccupyTheWeb – a comprehensive guide tailored for beginners, unveiling the fundamental principles of Linux within the context of cybersecurity.

At the heart of this book lies a simple yet profound premise: understanding Linux is paramount for anyone navigating the intricate pathways of ethical hacking. OccupyTheWeb, a pseudonymous figure deeply entrenched in the cybersecurity community, crafts a meticulous roadmap for enthusiasts, demystifying the complexities of Linux and its applications in security testing.

The journey begins with a meticulous exploration of the Linux command line – the quintessential tool in any hacker's arsenal. Through concise yet insightful explanations, readers are acquainted with essential commands, file manipulation techniques, and system navigation strategies. This foundational knowledge serves as the cornerstone upon which subsequent chapters build, fostering a solid understanding of Linux's inner workings.

Networking, a pillar of cybersecurity, receives ample attention as OccupyTheWeb delves into the intricacies of Linux-based network configuration and management. From understanding IP addressing to navigating firewalls, readers are equipped with the expertise needed to navigate the labyrinth of network security measures.

Scripting, another indispensable skill, is thoroughly elucidated, empowering readers to automate tasks and streamline processes with Bash scripting. Through practical examples and hands-on exercises, the book instills confidence in readers to harness the power of scripting for efficient and effective security operations.

What sets "Linux Basics for Hackers" apart is its unwavering focus on practicality. Each concept is accompanied by real-world examples and scenarios, enabling readers to translate theoretical knowledge into tangible skills. Whether it's conducting vulnerability assessments, performing reconnaissance, or executing penetration tests, the book seamlessly integrates Linux fundamentals into the fabric of ethical hacking practices.

Moreover, OccupyTheWeb's lucid writing style makes complex concepts accessible to novices without compromising on depth or detail. Concepts are presented in a logical progression, ensuring a smooth learning curve for readers irrespective of their prior experience with Linux or cybersecurity.

In an era where cybersecurity threats loom large, "Linux Basics for Hackers" serves as a beacon of empowerment for aspiring ethical hackers. It transcends the realm of traditional tutorials, offering a holistic understanding of Linux and its indispensable role in safeguarding digital assets. Whether you're a cybersecurity enthusiast, a budding ethical hacker, or an IT professional looking to bolster your skill set, this book is a must-have addition to your library.

In conclusion, "Linux Basics for Hackers" is not just a book; it's a manifesto for the next generation of cybersecurity practitioners. OccupyTheWeb's expertise shines through every page, guiding readers on a transformative journey from novice to proficient Linux users with a keen eye for security. So, if you're ready to embark on a voyage of discovery through the realm of Linux and ethical hacking, this book is your compass – pointing you towards knowledge, proficiency, and ultimately, mastery.

Live Stream Your Linux Screen to YouTube From The Terminal

2024-03-12T23:31:11+00:00

Prerequisites

Before we get started, let's make sure we have everything we need:

FFmpeg installed on my system.
A YouTube stream key, which you can find in your YouTube Live Dashboard.
(Optional) Conky, a lightweight system monitor for Linux.

Script Overview

I've created a Bash script that incorporates several functions to handle different aspects of the streaming process:

notif: Sends desktop notifications using notify-send.
ff_recscreen: Configures FFmpeg for screen recording and streaming.
ff_kill: Terminates the FFmpeg process.

Script Walkthrough

    

#!/bin/bash
youtube_streaming_key="your youtube streaming key"
function notif(){
    local n_id=12347
    n_msg="$1"
    notify-send -a "ffmpeg rec" -r $n_id -u low "$n_msg" -t 1000 -i notification-message-im
}

function ff_recscreen(){
    ffmpeg -loglevel debug \
           -threads:v 1 -threads:a 4 \
           -filter_threads 2 -thread_queue_size 512 \
           -f x11grab -video_size 1366x768 -framerate 30 -i :0.0+0,0 \
           -f pulse -i alsa_input.pci-0000_00_1f.3.analog-stereo -pix_fmt yuv420p \
           -c:v libx264 -qp:v 19 \
           -profile:v high \
           -af "volume=0.5" \
           -c:a aac -b:a 128k \
           -f flv rtmp://a.rtmp.youtube.com/live2/$youtube_streaming_key
}

function ff_kill(){
    rm /tmp/recording_in_progress 2> /dev/null
    pkill -2 ffmpeg
    kill -9 $(pgrep -f conky_recording)
    notif "streaming finished"
}

if [[ -f "/tmp/recording_in_progress" ]]
    then ff_kill
    else
         notif "Starting streaming"
         conky -c ~/.i3/conky/conky_recording &
         touch /tmp/recording_in_progress
         sleep 1.2
         ff_recscreen &
fi

Usage

Set Permissions: First, let's make the script executable by running chmod +x script_name.sh.
Edit the Script: Now, replace $youtube_streaming_key with your actual YouTube stream key in the script.
Run the Script: To start streaming, simply execute the script by running ./script_name.sh.

Script Overview

The Bash script automates the process of screen streaming using FFmpeg. When executed for the first time, it creates a temporary file to track the recording status. It then sends a notification, starts Conky for displaying this small icon in the top right corner of the screen, and initiates FFmpeg for screen recording and streaming. Subsequent executions of the script check for the existence of the temporary file. If the file exists, indicating an ongoing recording, the script terminates the FFmpeg and Conky processes, effectively stopping the streaming session.

Conclusion

With this script, you can easily initiate live streaming of your screen to platforms like YouTube using FFmpeg. Feel free to customize it further to suit your specific requirements or integrate additional features. Happy streaming!

A Comprehensive Guide to User and Group Administration in Linux

2024-03-09T22:48:52+00:00

User and group administration is a fundamental aspect of managing a Linux system. Whether you're setting up accounts for multiple users on a server or managing permissions for various groups within a team, understanding how to effectively manage users and groups is crucial. In this comprehensive guide, we'll explore the essential Linux commands for user and group administration, covering everything from creating and deleting users to modifying group memberships and permissions.

1. Creating Users:

The first step in user administration is creating user accounts. The useradd command is used for this purpose. Here's how you can create a new user:



useradd username

This command will create a new user account with the specified username. By default, the user's home directory will be created under /home/username.

2. Deleting Users:

If you need to remove a user account, you can use the userdel command:



userdel username

This command will delete the specified user account from the system. Be cautious when using this command, as it will also delete the user's home directory and any associated files.

3. Modifying User Accounts:

To modify user account properties such as the username, home directory, or default shell, you can use the usermod command. Here's an example of how to change a username:



usermod -l newusername oldusername

This command will rename the user account from oldusername to newusername.

4. Managing Passwords:

The passwd command is used to manage user passwords. You can use it to change a user's password:



passwd username

After entering this command, you'll be prompted to enter and confirm the new password for the specified user.

5. Creating Groups:

Groups allow you to manage permissions and access control for multiple users. You can create a new group using the groupadd command:



groupadd groupname

This command will create a new group with the specified groupname.

6. Deleting Groups:

To delete an existing group, you can use the groupdel command:



groupdel groupname

Be careful when deleting groups, as it will also remove any users that are exclusively members of that group.

7. Adding Users to Groups:

The usermod command can also be used to add users to groups. Here's how you can add a user to a group:



usermod -aG groupname username

This command will add the specified user to the specified group.

8. Displaying Group Memberships:

To see which groups a user is a member of, you can use the groups command:



groups username

This command will display a list of groups that the specified user is a member of.

9. Changing Group Ownership:

You can change the group ownership of a file or directory using the chgrp command:



chgrp groupname filename

This command will change the group ownership of the specified file or directory to the specified group.

Conclusion:

Effective user and group administration is essential for maintaining the security and integrity of a Linux system. By mastering the commands outlined in this guide, you'll have the knowledge and skills necessary to manage users and groups efficiently. Whether you're setting up accounts for a small team or administering a large-scale server environment, these commands will serve as valuable tools in your Linux administration toolkit.

wchanger: A Powerful Wallpaper Changer for i3

2024-03-08T13:57:32+00:00

Introducing wchanger: A Powerful Wallpaper Changer for i3

Do you find yourself constantly wanting to refresh your desktop background with new and exciting wallpapers? Look no further than wchanger, the ultimate wallpaper changer designed specifically for i3 window manager users. With its plethora of features and customizable options, wchanger takes your desktop customization to the next level.

What is wchanger?

wchanger is a versatile wallpaper changer script tailored for i3 users. It seamlessly integrates into the i3 environment, allowing users to effortlessly switch between various wallpapers on different workspaces.

Key Features

Multi-Layered Wallpaper Management
Workspace-Specific Settings
Extensive Command Line Interface

Installation Guide

Getting started with wchanger is quick and straightforward. Simply follow these steps:

Run the provided install.sh script:
```
$ ./install.sh
```

Create a systemd service for wchanger:



$ sudo cp wchanger.service /usr/lib/systemd/user/wchanger.service

Enable the wchanger service:
```
$ systemctl --user enable wchanger
```
Start the wchanger service:
```
$ systemctl --user start wchanger
```

Help and Usage

Navigating wchanger is made easy with its intuitive help and usage guide. Here are some essential commands:

Adding Favorites: af|addfav
Managing Lists: al|addlist [name] [c]
Changing Wallpaper Mode: cm|setmode [number]
Previewing Montage: l|list [o,l,number]
Updating Database: updatedb [scan]

And so much more, just following its interactive help will get you started right away

running wchanger for the first time in a workspace

When initially utilizing wchanger on any workspace, users are greeted with an intuitive and interactive help system aimed at simplifying the setup process. If a mode is not defined, wchanger automatically defaults to "getwW" mode. With this mode, the script fetches the wallpapers from wallhaven website, with the default search query "nature". To set the mode, users can utilize the simple command "wchanger sm". This interactive approach guarantees that users can effortlessly configure wchanger to suit their preferences from the very first use.

setting wchanger mode for the workspace

setting the search id/tag for the workspace

A montage of the wallpapers of the current mode

For more information, wchanger is available on GitHub. Unfortunately, I no longer update it. The repository is 5 years old, but it continues to work well for me. However, the code definitely needs improving. Feel free to explore the repository and contribute to its development!

Conclusion

With wchanger, i3 users can elevate their desktop experience with dynamic and personalized wallpapers. Whether you're a minimalist or a wallpaper enthusiast, wchanger empowers you to curate your desktop environment to reflect your unique style and preferences. Try wchanger today and revolutionize your desktop customization experience!

Enhance Your i3 Workflow: Keybinding Visualization Made Easy

2024-03-07T18:21:28+00:00

Introduction

I've been exploring the depths of the i3 window manager, reveling in its customization options and efficiency. Keybindings, in particular, are crucial for navigating my workflow seamlessly. However, managing, remembering and visualizing these keybindings can sometimes be challenging. That's where a simple Bash script comes to the rescue.

The Script

Let me introduce you to a handy Bash script that simplifies the management and visualization of i3 keybindings. Here's how it works:

It checks for the existence of a keybindings file: '/tmp/i3wm-keys'. If the file exists, it removes it and kills any running instances of Conky.

If the file doesn't exist, the script then filters the lines of i3 config file. The script extracts only the keybindings I want to list and show later,this is done by filtering out lines that don't start with a leading space before " bindsym". I have intentionally put the leading space in the beginning of the lines of some irrelevant keybindings in the i3 configuration file.

These keybindings are then formatted neatly in the file '/tmp/i3wm-keys' waiting to be fed to conky.

Finally, the script starts Conky, a lightweight system monitor, to display the keybindings in a customizable way.

the scirpt:

    

#!/bin/bash
if [[ -f /tmp/i3wm-keys ]]
    then
        rm /tmp/i3wm-keys
        killall conky
        killall conky
    else
    grep '^bindsym' ~/.i3/config |
        sed 's/bindsym//g;s|~/.i3/||g;s|~/bin/||g' |
        sed 's/mod1/alt/g' |
        sed 's/\$mod/win/g' |
    sed 's|~/.config/wchanger/||g' |
        sed 's/exec --no-startup-id/ /g' |
        awk '{
            keys[NR]=$1;
            for (i=2; i<=NF; i++) {
                command[NR]=command[NR] $i " ";
            }
        }
        END {
            for (i=1; i<=NR; i++) {
                key = sprintf("%-25s", keys[i]);
                cmd = sprintf("%-35s", command[i]);
                gsub(/ /,".",key);
                printf "%s %s    ", key, cmd;
                if (i % 2 == 0) printf "\n"; else printf " ";
            }
        }' > /tmp/i3wm-keys
    nohup conky -c "${HOME}/.i3/conky/shortcuts" </dev/null >/dev/null 2>&1 &
fi

The text goes over many filtering and cleanning steps, the last one of them is using awk that will format the key/command pairs. Finally saving it in the file '/tmp/i3wm-keys' before feeding it to the following conky script:

    

conky.config = {
    use_xft = true,
    font = 'DejaVu Sans Mono:size=13',
    xftalpha = 0.1,
    update_interval = 1,
    total_run_times = 0,

    own_window =true,
    own_window_type ="desktop",
    own_window_type ="override",
    own_window_transparent =true,
    own_window_hints ="undecorated,below,sticky,skip_taskbar,skip_pager",
    own_window_colour ="000000",
    own_window_argb_visual =true,
    own_window_argb_value =255,

    double_buffer = true,
    minimum_width =1150,
    maximum_width =1250,
    draw_shades = false,
    draw_outline = false,
    border_width = 1,
    draw_borders = false,
    draw_graph_borders = false,
    default_color = 'white',
    default_shade_color = 'red',
    default_outline_color = 'green',
    alignment = 'top_middle',
    gap_x = 10,
    gap_y = 10,
    no_buffers = true,
    uppercase = false,
    cpu_avg_samples = 2,
    net_avg_samples = 1,
    override_utf8_locale = true,
    use_spacer = 'none',
}

conky.text = [[
${color green}\
${voffset 15}\
${goto 370}\
${color green}\
_______________\
 .: i3wm shortcuts :. \
_______________\
${color lightblue}
${voffset +10}
${exec cat /tmp/i3wm-keys}
]]

Conclusion

In conclusion, this Bash script offers a simple yet effective solution for managing and visualizing i3 keybindings. Whether you're a seasoned i3 user or just getting started, integrating this script into your workflow can enhance your productivity and overall experience. Give it a try, and take control of your i3 keybindings like never before.

Thank you for reading, and feel free to explore further or reach out with any questions or feedback in the comments section below.

Top Ways to Capture Screenshots on Your Linux System

2024-03-03T21:23:13+00:00

Introduction

Welcome to our guide on capturing screenshots in Linux! As a Linux user, you have several options for taking screenshots, ranging from built-in keyboard shortcuts to specialized tools. In this tutorial, I'll walk you through various methods you can use to capture screenshots on your Linux system.

Using Built-in Keyboard Shortcuts

Linux offers some handy keyboard shortcuts for taking screenshots:

Print Screen (PrtSc): Pressing this key captures the entire screen.
Alt + Print Screen: Pressing these keys together captures only the active window.

GNOME Screenshot Tool

If you're using the GNOME desktop environment, you can take advantage of the GNOME Screenshot utility.

Even if you're not using the GNOME desktop environment, you can still install and use the GNOME Screenshot utility:

Install GNOME Screenshot using your package manager (e.g., sudo apt install gnome-screenshot for Debian-based systems).
Access GNOME Screenshot by searching for it in the application menu or launching it from the terminal with the command gnome-screenshot.
Features include capturing specific areas, adding delays, and choosing where to save the screenshots.

Screenshot of gnome-screenshot

KDE Spectacle

For KDE Plasma users, the default screenshot tool is Spectacle:

Launch Spectacle from the application menu or by pressing Alt + F2 and typing spectacle.
You can capture the full screen, a specific window, or a custom region with Spectacle.

Command-Line Tools

If you prefer using the command line, Linux offers some powerful screenshot utilities:

scrot: A command-line tool for taking screenshots.
import: Part of the ImageMagick suite, allows for capturing screenshots and saving them as images.

You can use scrot and import like this:

    

#!/bin/bash
#
# script using import to save a screenshot of the desktop
#
filename="screenshot-$(date '+%Y-%m-%d--%H-%M-%S').png"
#scrot "/tmp/$filename"
import -window root "/tmp/$filename"
if [[ "$1" == "1" ]]
    then
          convert "/tmp/$filename" -crop 1366x768+0+0 "/tmp/$filename"
    else
          convert "/tmp/$filename" -crop 1920x1080+1366+0 "/tmp/$filename"
fi
mv "/tmp/$filename" "${HOME}/Pictures/$filename"
mpv --no-config  ${HOME}/.i3/Nikon.ogg

Shutter

Shutter is a feature-rich screenshot tool available for Linux:

Install Shutter using your package manager or download it from the official website.
Features include annotations, editing, and sharing options.

Flameshot

Flameshot is a lightweight screenshot tool with annotation features:

Install Flameshot from your distribution's software repository.
It offers simplicity and speed, making it a popular choice among users.

Other Notable Methods

In addition to the methods mentioned above, you can also use browser extensions or third-party software for taking screenshots on Linux. However, these may have their own pros and cons, so it's essential to choose the one that best fits your needs.

Conclusion

Capturing screenshots in Linux is easy and versatile, thanks to the various methods available. Whether you prefer built-in keyboard shortcuts, desktop utilities like GNOME Screenshot and Spectacle, or third-party tools like Shutter and Flameshot, there's something for everyone. Experiment with different methods to find the one that works best for you!

Take Command of your Cheatsheets with this script

2024-02-28T22:17:03+00:00

Introduction:

In the world of shell scripting, simplicity and functionality often go hand in hand. The provided shell script is a testament to this philosophy. It serves as a versatile tool for both note-taking and managing cheatsheets, all within the familiar environment of the command line.

The Script:

    

#!/bin/zsh

if [[ $1 == "-e" ]] ; then
    vim  "${HOME}/.cheat/$2"
    exit
fi
if [[ $1 == "-l" ]] ; then
    ls  "${HOME}/.cheat/"
    exit
fi

less -p '^#.*' -R "${HOME}/.cheat/$1"

Usage:

The script offers three main functionalities:

Editing Notes/Cheatsheets: By providing the option -e followed by the name of the cheatsheet, the script opens the file in Vim for editing. For instance: ./script.sh -e ffmpeg
This command opens the ffmpeg file for editing within the Vim text editor.
Listing Available Cheatsheets: The option -l lists all available cheatsheets stored in the .cheat directory. For example: ./script.sh -l This command displays a list of all cheatsheets present in the .cheat folder.
Viewing Cheatsheets: If neither -e nor -l options are provided, the script assumes the argument is the name of the cheatsheet to view. It then displays the contents of the cheatsheet using the less pager, highlighting lines starting with #, which often denote comments or headings.

Example usage of cheat script

You can press v while in less command to enter editing mode with vim

Editing the cheat file in vim

Usage Optimization:

To streamline usage even further, creating an alias for this script is a clever move. For instance, you could set up an alias like `cheat` that points to the script's location. This way, invoking the script becomes as simple as typing `cheat` followed by the desired command or option.

Moreover, leveraging the autocomplete feature of zsh can enhance efficiency even more. By configuring Zsh's autocomplete settings, you can enable suggestions for cheatsheet names stored within the `.cheat` directory. For instance, when typing `cheat` and pressing the `TAB` key, Zsh can present a dropdown menu of all available cheatsheets, allowing for quick selection without the need to recall filenames manually. This integration seamlessly integrates the script into your workflow, making accessing cheatsheets a breeze.

In practice, this autocomplete feature looks like this:

cheat autocomplete

Benefits:

Efficiency: With this script, accessing and managing cheatsheets becomes a seamless process directly from the command line, saving valuable time and effort.
Organization: All cheatsheets are stored within the .cheat directory, keeping your notes neatly organized and easily accessible.
Customization: The script is easily customizable to suit individual preferences or workflow requirements. Users can modify it to integrate additional features or tailor it to specific use cases.

Conclusion:

In the realm of command-line productivity, having quick access to notes and cheatsheets can greatly enhance workflow efficiency. This shell script provides a simple yet effective solution, empowering users to manage their notes effortlessly and focus on the task at hand. With its versatility and ease of use, it stands as a valuable tool in the toolkit of any command-line aficionado.

Empowering Your Media Experience: MPV Control with Command Line and socat

2024-02-25T14:50:19+00:00

Introduction:

In this article, I'm going to show you how to take command of MPV, a powerful media player, directly from the comfort of your command line using socat. Together, we'll unravel the intricacies of socat's capabilities, enabling us to interact with MPV seamlessly and efficiently, all with just a few keystrokes.

MPV and socat

Let's delve into the fundamentals of MPV and socat to grasp their roles in command line media control.

MPV stands out as a versatile media player renowned for its wide range of features and robust performance. It supports various audio and video formats, making it a popular choice among media enthusiasts.

On the other hand, socat serves as a powerful utility for establishing bidirectional data transfer between two independent processes. Its flexibility and efficiency make it an ideal tool for facilitating communication between MPV and the command line interface.

Setting up MPV and socat

Let's walk through the steps to configure MPV and socat for seamless command line control.

To begin, ensure that MPV and socat are installed on your system. You can easily install them using your package manager on Linux distributions.

Once installed, you have two options to configure MPV for remote control:

Pass the --input-ipc-server=/path/to/your/socketfile option when starting MPV.
Alternatively, you can directly modify the MPV configuration file "~/.config/mpv/mpv.conf" like this:

    

# add the following line to ~/.config/mpv/mpv.conf
input-ipc-server =/tmp/mpvsocket

Bash functions for controlling MPV

Let's dive into the bash functions designed to streamline MPV control directly from the command line.

Function: mpvVolume()

    

# $1 +<number> or -<number>
function mpvVolume(){
    echo "add volume $1" | socat - "$mpvsocketfile"
    data=$(
            echo '{ "command": ["get_property", "volume"] }' \
            | socat - "$mpvsocketfile" \
            | jq '.data'
    )
    msg="${data%.*}"
}

This function adjusts the volume of MPV by a specified increment or decrement.

Usage: mpvVolume +<number> or mpvVolume -<number>

The function sends the volume adjustment command to MPV via socat, followed by querying the current volume level. The jq command is used to filter the retrieved data. If you want to get to know how to use it check this article : jq tutorial : How To Get COVID stats and data from your terminal

The message retrieved is utilized for notifications at the end of my shell script.

Function: mpvPause()

    

function mpvPause(){
    echo 'cycle pause' | socat - "$mpvsocketfile"
    data=$(
    echo '{ "command": ["get_property", "pause"] }' \
        | socat - "$mpvsocketfile" \
        | jq '.data'
    )
    if [[ "$data" == "true" ]]
        then msg=pause
        else msg=play
    fi
}

This function toggles the pause state of MPV.

Usage: mpvPause

The function sends the 'cycle pause' command to MPV via socat to toggle the pause state. It then retrieves the current pause state using jq to filter the data.

If the pause state is true, indicating that MPV is paused, the message is set to 'pause'; otherwise, it is set to 'play'.

Functions: mpvNext(), mpvPrev()

    

function mpvNext(){
    echo 'playlist-next' | socat - "$mpvsocketfile"
}

function mpvPrev(){
    echo 'playlist-prev' | socat - "$mpvsocketfile"
}

The mpvNext() function instructs MPV to play the next item in the playlist.

This function sends the 'playlist-next' command to MPV via socat, prompting it to play the next item in the playlist.

The function mpvPrev() instructs MPV to play the previous item in the playlist.

This function sends the 'playlist-prev' command to MPV via socat, prompting it to play the previous item in the playlist.

Other functions

    


# Function to retrieve the total number of items in the MPV playlist
function mpvPlaylistCount(){
    cmd='{ "command": ["get_property", "playlist-count"] }'
    echo "$cmd" \
        | socat - "$mpvsocketfile" 2>/dev/null \
        | jq '.data'
}

# Function to retrieve the current position in the MPV playlist
function mpvPlaylistPos(){
    cmd='{ "command": ["get_property", "playlist-pos"] }'
    echo "$cmd" \
        | socat - "$mpvsocketfile" 2>/dev/null \
        | jq '.data'
}

# Function to set the current position in the MPV playlist to the specified number
function mpvSetPlaylistPos(){
    number=$1
    cmd='{ "command": ["set_property", "playlist-pos", "'
    cmd+="$number"
    cmd+='" ] }'
    echo "$cmd" \
        | socat - "$mpvsocketfile" 2>/dev/null \
        | jq '.data'
}

These additional functions provide essential functionality for managing MPV playlists with ease. The `mpvPlaylistCount()` function retrieves the total number of items in the playlist, allowing users to ascertain the size of their playlist dynamically. The `mpvPlaylistPos()` function retrieves the current position in the playlist, enabling users to track their progress or determine which item is currently playing. Finally, the `mpvSetPlaylistPos()` function sets the current position in the playlist to the specified number, facilitating seamless navigation within the playlist. Together, these functions enhance the control and management of MPV playlists, providing users with a convenient way to interact with their media collections.

Adding notifications

Additionally, you can enhance your MPV control setup by incorporating notifications using the media title. By appending the media title to the message, retrieved using the 'get_property', 'media-title' command, you can provide informative notifications while utilizing the MPV control functions. These notifications can be displayed using tools like dunstify, ensuring that you stay informed about the currently playing media and control actions.

    

msg+=" | "
msg+=$(
  echo '{ "command": ["get_property", "media-title"] }' |
  socat - "$mpvsocketfile" |
  jq '.data'
)
dunstify -a "media-controls"  -u low  -r "$msgId" "mpv: $msg"
echo "$msg"

Practical examples

Let me show you how I use these functions in my workflow

For instance, in my i3 window manager configuration file, I've integrated MPV control into various keybindings. This setup allows me to effortlessly control MPV even when its window is in another workspace. For example, Let's say I'm writing something in workspace 3 and mpv is playing in workspace 5, No need to navigate there, just by typing "Alt+Space" to pause MPV and "Alt+V" to increase the volume, I don't have to disrupt my workflow.

MPV Control Notification

Conclusion

As we conclude our exploration, it's evident that controlling MPV from the command line using socat opens up a world of possibilities for seamless media management.

With the power of bash functions and socat, you can effortlessly interact with MPV, whether it's adjusting volume, toggling playback, or navigating playlists.

By incorporating these techniques into your workflow, you can streamline your media experience and enhance productivity, all while enjoying the flexibility and customization offered by command line control.

References

For more information and official documentation on the tools and concepts discussed in this article, refer to the following resources:

MPV Documentation

Official MPV documentation provides comprehensive guidance on installation, configuration, and usage of the MPV media player.
https://mpv.io/manual/

socat Documentation

The official socat documentation offers detailed information on the usage and features of socat, a versatile tool for data transfer between processes.
http://www.dest-unreach.org/socat/doc/socat.html

dunstify Documentation

Explore the official dunstify documentation to learn more about creating desktop notifications from the command line using dunstify.
https://github.com/dunst-project/dunst

Terminal Magic: Simplifying Image Editing for Busy Professionals

2024-02-24T17:22:41+00:00

Are you like me, you don't like to edit images, or rather you don't have the time to waste learning how to use sophisticated image editing software like Gimp or Photoshop, but sometimes you want to make thorough changes to images. This article is just for you.

In this article, I am going to show you just how easy it is to add a red hue to an image, flip it blur a part of it or just crop it with single commands in your terminal and much more. Image editing will become a fun activity as you hack your way around it. So let's get started

1. Flip and Flop

Flipping and flopping images can offer a fresh perspective or correct orientation with just a simple command. Whether it's turning a landscape shot on its head or adjusting the orientation of a portrait, the terminal holds the key to effortless transformations. here is how to do it

    

# I resized a big image for this article:
convert hummingbird.jpg -resize 20% hummingbird-small.jpg
# flop (mirror) it
convert hummingbird-small.jpg -flop hummingbird-flop.jpg
# flip it (vertically)
convert hummingbird-small.jpg -flip hummingbird-flip.jpg

Original

flop: mirrored

flip: vertically

So, for flipping (mirroring) horizontally, you use -flop, and for flipping vertically, you use -flip. I hope this clears up any confusion.

2. Red or Green Hue

Injecting a burst of color into your images is now just a command away. Say goodbye to the complexities of intricate editing software and hello to vibrant imagery with a single terminal command. Whether it's a bold red hue to intensify emotions or a serene green tint to evoke nature's tranquility

    

convert hummingbird-small.jpg -channel G -evaluate set 50% +channel hummingbird-green.jpg
convert hummingbird-small.jpg -channel B -evaluate set 50% +channel hummingbird-blue.jpg
convert hummingbird-small.jpg -channel R -evaluate set 50% +channel hummingbird-red.jpg

red hue

green hue

blue hue

3. Blur or Erase a Part of the Image

Ever wished to blur out sensitive information or seamlessly remove distractions from your images? With terminal magic, achieving a polished and professional look is easier than you think. From blurring out background noise to erasing unwanted elements, I'll demonstrate how to wield the power of image manipulation with precision and finesse.

Here's the command to do it:



convert input.jpg -region WxH+X+Y -blur 0x8 output_blurred.jpg

Replace `input.jpg` with the name of your input image file, `W` and `H` with the width and height of the rectangle, and `X` and `Y` with the coordinates of the top-left corner of the rectangle. Adjust the `0x18` parameter in the `-blur` option to control the intensity of the blur effect (larger values mean more blur).



convert hummingbird-small.jpg -region 170x750+0+0 -blur 0x18 hummingbird-blurred.jpg

blur effect

4. Convert Font Awesome Icons Text to Images

Rather than loading the Font Awesome CDN on my website just to use a few icons, I create them myself. Whether it's for presentations, graphics, or personal projects, this approach allows for greater flexibility and control over icon usage without the overhead of external dependencies. Transforming text-based icons into versatile images opens up a world of creative possibilities tailored to individual needs and preferences.

I have a file icon-list.txt with a huge list of Font Awesome icons in Unicode like this:

    

<span lang='heart' foreground='#78d5e8' face='Font Awesome'>&#xf004;</span> heart
<span lang='star' foreground='#a9b2fc' face='Font Awesome'>&#xf005;</span> star
<span lang='star-o' foreground='#f2fc83' face='Font Awesome'>&#xf006;</span> star-o
<span lang='user' foreground='#a0ff77' face='Font Awesome'>&#xf007;</span> user
<span lang='film' foreground='#f7b0af' face='Font Awesome'>&#xf008;</span> film
<span lang='th-large' foreground='#9890f4' face='Font Awesome'>&#xf009;</span> th-large
<span lang='th' foreground='#fcedc2' face='Font Awesome'>&#xf00a;</span> th

And here is the shell script I use to create icons:

    

#!/bin/bash

options='-columns 6 -width 100 -lines 20 -bw 2 -yoffset -20 -location 1'

selected=$( cat ~/.i3/icon-list.txt | rofi -dmenu -i -markup-rows -p "Select icon")

# exit if nothing is selected
[[ -z $selected ]] &&  exit

iconcode=$( echo "$selected" | awk -F';' -v RS='>' 'NR==2{sub("&#x","",$1);print "\\u" $1;exit}' )
color=$( echo "$selected" | sed -E "s/^.*='#(.{6}).*$/\1/" )
icon=$(echo -ne $iconcode)
iconname=$( echo "$selected" | cut -d\' -f2 )

r=$(printf "%d" "0x${color:1:2}")
g=$(printf "%d" "0x${color:3:2}")
b=$(printf "%d" "0x${color:5:2}")

file="${HOME}/Pictures/icons/${iconname}.png"
echo "Selected icon name: $iconname"
echo "Selected icon : $icon"

convert -size 50x50 xc:none -background none -font "/home/mosaid/.fonts/fa-solid-900.ttf" -pointsize 48 -fill "rgba($r,$g,$b,1)" -gravity center -draw "text 0,0 '$icon'" "$file"

feh $file

The script utilizes `rofi` to display the icon list interactively, facilitating seamless selection of the desired icon. Once a selection is made, the script employs the powerful `convert` command from ImageMagick to transform the chosen icon's Unicode representation into a PNG image. This image is then promptly displayed using `feh`, providing immediate visual feedback and enabling further exploration or utilization.

And finally, the Awesome banner of this article is created with this script:

    

#!/bin/bash
# Create image with simple shapes
convert -size 1600x800 xc:none \
-fill "rgba(0,0,255,0.3)" -draw "rectangle 0,0,1600,800" \
-fill "rgba(255,0,0,0.5)" -draw "circle 300,300 600,600" \
-fill "rgba(55,255,0,0.5)" -draw "rectangle 1300,300 1600,800" \
-fill "rgba(0,255,0,0.7)" -stroke "rgba(255,255,0,0.7)" -strokewidth 10 -draw "line 300,50 1500,250" \
-font "DejaVu-Sans-Mono-Bold" -pointsize 130 -fill "rgba(255,155,55,1)" \
-gravity center -size 800x -fill "rgba(255,155,55,1)" \
-draw "text 20,0 'How to edit images'" \
-draw "text 100,200 'from terminal'" image.png

Capture Your Screen Like a Pro in i3wm: Complete Setup and Configuration

2024-02-22T22:08:34+00:00

Introduction

In this tutorial, I'll guide you through setting up efficient screen recording capabilities within the i3 window manager (i3wm) environment using ffmpeg. i3wm is a highly customizable tiling window manager, prized for its minimalism and efficiency. Screen recording is a valuable tool for various purposes, including creating tutorials, delivering presentations, and reporting software bugs. By leveraging the flexibility of i3wm and the power of ffmpeg, you can create a seamless workflow for capturing and sharing your screen content.

Setting up i3 Configuration

Configuring i3wm to facilitate screen recording is straightforward. Start by editing the i3 configuration file located at ~/.config/i3/config. Within this file, you can define keybindings to execute specific commands. For our purpose, we'll assign a key combination to initiate the screen recording process.

Here's an example of how to define a keybinding to trigger the screen recording script:



bindsym mod1+r exec --no-startup-id ~/bin/ff_screen_rec

In this snippet, mod1+r represents the key combination (in this case, Alt + r) that will activate the screen recording. The exec command is used to execute a shell command, and --no-startup-id ensures that the command runs asynchronously without waiting for startup notifications. finally the ff_screen_rec is my bash script

Creating the Screen Recording Script

To facilitate screen recording within the i3wm environment, we'll create a custom Bash script utilizing ffmpeg. This script automates the process of capturing the screen and optionally recording audio inputs.

Below is the Bash script:



#!/bin/bash

function ff_recscreen(){
    # Function to initiate screen recording

    # Define output file path with timestamp
    outputfile="${HOME}/Videos/ff_rec/$(date +%G_%m_%d_at_%H-%M-%S).mkv"

    # Determine audio input and output sources
    audioInputSource=$(pactl list sources short | awk '{print $2}' | grep input | tail -1)
    audioOutputSource=$(pactl list sources short | awk '{print $2}' | grep output | tail -1)

    # Get screen resolution
    SCREEN_res=$(xrandr -q --current | grep '*' | awk '{print $1}' | head -1 )

    # Set screen capture area based on input parameter
    if [[ "$1" == "2" ]]; then
        screen="1920+0"
    else
        screen="0+0"
    fi

    # Print audio and screen information
    printf '\033[1;32m audio1 : \033[1;0m %s\n' "$audioInputSource"
    printf '\033[1;32m audio2 : \033[1;0m %s\n' "$audioOutputSource"
    printf '\033[1;32m screen : \033[1;0m %s\n' "$SCREEN_res +0.0+$screen"

    # Prompt user to continue
    IFS= read -rN 1 -p "continue (Y/n) ? : " answer
    echo
    [[ "$answer" == "n" ]] &&  return

    # Construct ffmpeg command for screen recording
    cmd="ffmpeg"
    if [[ -n $audioInputSource  ]] ; then
        cmd+=" -f pulse -thread_queue_size 1024 -ac 2 -i $audioInputSource"
    fi
    if [[ -n $audioOutputSource ]] ; then
        cmd+=" -f pulse -thread_queue_size 1024 -ac 2 -i $audioOutputSource"
    fi
    cmd+=" -f x11grab -thread_queue_size 1024 -r 30 -s $SCREEN_res -i :0.0+$screen"
    cmd+=" -vf scale=trunc\(iw/2\)*2:trunc\(ih/2\)*2"
    cmd+=' -c:v libx264 -preset ultrafast -crf 18'
    cmd+=' -af highpass=f=200,lowpass=f=3000'
    cmd+=" -acodec pcm_s16le"
    cmd+=" -threads 0"
    cmd+=" $outputfile"

    # Update i3blocks and indicate recording in progress
    pkill -RTMIN+14 i3blocks
    touch /tmp/recording_in_progress
    $cmd &
}

function ff_kill(){
    # Function to stop screen recording and cleanup

    # Remove recording flag file
    rm /tmp/recording_in_progress 2> /dev/null

    # Terminate ffmpeg process
    pkill -2 ffmpeg

    # Update i3blocks
    pkill -RTMIN+14 i3blocks
}

# Check if recording is in progress
if [[ -f "/tmp/recording_in_progress" ]]; then
    ff_kill
else
    ff_recscreen
fi

When the recording process starts, the script creates a temporary file to indicate that recording is in progress. It also sends a signal to i3blocks to update its status indicator accordingly. Conversely, when the recording ends, the script runs differently based on the presence of the temporary file. This approach ensures seamless integration with i3wm's status bar and facilitates efficient management of the recording process.

Integrating with i3blocks

i3blocks serves as a valuable tool for displaying status information in the i3wm status bar. Integrating our screen recording setup with i3blocks allows for seamless monitoring of the recording process.

To configure i3blocks for this purpose, we define a custom block in the i3blocks configuration file. This block executes a script to provide real-time updates on the recording status.

Here's an example of how to configure i3blocks:



[recording_status]
color=#FF0000
command=~/.i3/top-bar/recording_status.sh
interval=once
signal=14

The above configuration defines a block named recording_status with a red color indicator. It executes the script ~/.i3/top-bar/recording_status.sh to fetch the recording status. The interval=once parameter ensures that the script is executed only once per interval, and the signal=14 specifies the signal to be sent for updates.

Now, let's take a look at the shell script responsible for providing the recording status:



#!/bin/bash

if [[ -f /tmp/recording_in_progress ]]; then
    echo " "
else
    echo ""
fi

This script checks for the existence of the /tmp/recording_in_progress file. If the file exists, it echoes a small in the top right corner of my screen to indicate that a recording is in progress. Otherwise, it echoes nothing, indicating that no recording is currently taking place.

To initiate screen recording, simply press Alt + r on your keyboard. To stop the recording, press Alt + r again. And the recording process will be termianted, then the icon in i3blocks will disappear, signifying that the recording has ended.

Conclusion

In conclusion, integrating screen recording capabilities into the i3 window manager environment offers a seamless and efficient solution for capturing your screen content. By leveraging the power of ffmpeg for recording and i3blocks for status indication, users can easily initiate, monitor, and manage screen recordings directly within their i3wm setup.

This setup not only provides convenience but also enhances productivity by streamlining the screen recording process. Whether creating tutorials, presentations, or bug reports, i3wm users can rely on this integrated solution to meet their recording needs effectively.

With the flexibility to customize and extend the setup further, users can tailor it to their specific requirements and preferences. Overall, incorporating screen recording functionality into i3wm enhances the user experience and adds valuable capabilities to this lightweight and customizable window manager.

Appendix: Troubleshooting and FAQs

Here are some common troubleshooting tips and frequently asked questions related to setting up screen recording within the i3 window manager:

1. Screen Recording Not Starting

If the screen recording does not start when pressing Alt + r, ensure that the keybinding is correctly configured in your i3 configuration file. Double-check the syntax and ensure that the script path is accurate.

2. No Audio in Recorded Videos

If your recorded videos lack audio, verify that the audio input and output sources are correctly specified in the screen recording script. Additionally, ensure that the selected audio sources are functioning properly and not muted.

3. i3blocks Not Displaying Recording Status

If i3blocks does not show the recording status indicator, check the configuration of the [recording_status] block in your i3blocks configuration file. Ensure that the command path and signal number match the setup described in this tutorial.

4. Recording Quality or Performance Issues

If you encounter issues related to recording quality or performance, consider adjusting the ffmpeg parameters in the screen recording script. Experiment with different settings such as frame rate, resolution, and encoding options to optimize the recording quality and performance for your system.

5. Check xsession-errors file for erros

you can check tail -f ~/.xsession-errors for more i3wm troubleshooting.

If you have further questions or need troubleshooting assistance, feel free to comment below, and I'll be glad to help!

References and Resources

Here are some valuable references and resources for further learning and exploration:

1. i3wm Documentation

Official documentation for the i3 window manager, providing comprehensive guides and references for configuring and using i3wm effectively.

2. ffmpeg Documentation

Official documentation for ffmpeg, offering detailed explanations of ffmpeg's features, options, and usage for audio and video processing tasks.

3. i3blocks Documentation

Documentation for i3blocks, containing information on configuring and customizing i3blocks for displaying status information in the i3wm status bar.

4. Online Forums and Communities

Engage with the i3wm and ffmpeg communities through online forums and discussion platforms such as Reddit's i3wm community. These communities often provide valuable insights, tips, and solutions for troubleshooting and optimization.

Explore these resources to deepen your understanding of i3wm, ffmpeg, and related tools, and to connect with fellow users for support and collaboration.

Comprehensive Guide to the find Command in Linux

2024-02-18T20:47:18+00:00

Welcome to my comprehensive guide on using the find command in Linux. Whether you're a beginner or an experienced user, mastering the find command can significantly enhance your ability to navigate and manipulate files and directories in the Linux environment.

Basic Syntax and Usage

The find command in Linux is incredibly versatile, allowing you to search for files and directories based on various criteria. Here's the basic syntax:



find [path...] [expression]

To find files by case-insensitive extension (e.g., .jpg, .JPG, .jpG), you can use:



find . -iname "*.jpg"

Similarly, to find directories:



find . -type d

And to find files:



find . -type f

Searching for Files and Directories

When searching for files, you can specify additional criteria such as permissions or file type. For example, to find files with octal permission 777:



find . -type f -perm 777

To find files modified more than 7 days ago:



find . -type f -mtime +7d -ls

And to search for symlinks owned by a specific user:



find . -type l --user=username -ls

Performing Actions on Found Items

Once you've found the files or directories you're interested in, you can perform various actions on them. For instance, to delete files with a specific extension, you can use:



find ./path/ -name '*.txt' -exec rm '{}' \;

To modify permissions of found files:



find . -type f -exec chmod 644 {} \;

Combining Multiple Criteria

Combining multiple search criteria can help you narrow down your results effectively. You can use logical operators like -o and -prune to exclude certain directories or files from the search. For example, to find all directories except tmp:



find /path/to/dest -type d \( ! -name tmp \) -print

Advanced Usage

The find command supports advanced usage scenarios, such as searching for files based on size or modification time. For instance, to find files bigger than 2 Megabytes and list them using the ls command with all their information from permissions to size:



find . -type f -size +200000000c -exec ls -lh {} \; | awk '{ print $9 ": " $5 }'
#the same as
find . -type f -size +2M -exec ls -lh {} \; | awk '{ print $9 ": " $5 }'

You can play with the fields of awk command to get your desired output.

Best Practices and Tips

Be cautious when using -exec to perform actions on found items, as it executes the command for each found item.
Combine find with other commands like grep or xargs for more complex operations.
Regularly review and test your find commands before performing actions like deletion to avoid unintended consequences.

Conclusion

The find command is an indispensable tool for navigating and managing files and directories in Linux. By mastering its syntax and various options, you can streamline your workflow and perform tasks more efficiently. I encourage you to experiment with the examples provided and explore further possibilities offered by this powerful command.

How I Control My PC from My Phone: A Guide Using Termux, SSH, and SSHpass

2024-02-16T22:49:44+00:00

Introduction

Hey there, fellow tech enthusiasts! Imagine having the power to control your PC right from the palm of your hand. Well, buckle up because I'm about to show you how I do just that using Termux, SSH, and SSHpass. Get ready to unlock a whole new level of convenience and productivity!

Setting Up Termux, SSH, and SSHpass

Install Termux: First things first, head over to the Google Play Store or F-Droid and install Termux on your Android device. It's a powerful terminal emulator that's perfect for our needs.
Install SSH: Once you've got Termux up and running, install the OpenSSH package using the package manager:
```
    

pkg install openssh
```
Install SSHpass: Additionally, install SSHpass, a handy tool for non-interactive SSH password authentication:
```
    

    pkg install sshpass
```

Setting Up SSH on Your PC

Enable SSH: Now, let's head over to our PC running Arch Linux and enable SSH. If you haven't already, install the openssh package and start the SSH service:
```
    

    sudo pacman -S openssh
```
Configure SSH: To ensure secure connections, let's configure SSH by setting up SSH keys for authentication. This adds an extra layer of security and convenience.

Connecting Your Phone to Your PC

Find PC's IP Address: Open up a terminal in Termux and find your PC's local IP address using the ifconfig or ip addr command.
Connect via SSH: With the IP address in hand, establish a connection to your PC from Termux using SSHpass. Use the following command, replacing "mylinuxpassword" with your actual password, myusername with your username, and 192.168.1.12 with your PC's IP address:
```
    

    ssh myusername@192.168.1.12
```
This command will prompt for your password and establish a secure SSH connection to your PC.

after the first connection with ssh, you can skip the part of the password prompt everytime using sshpass like so:

    

sshpass -p "mylinuxpassword" ssh myusername@192.168.1.12

Screenshot: ranger file manager

Executing Commands from Your Phone

Basic Commands: Start off by running some basic commands like ls, pwd, and date directly from your phone. It's like having a mini Linux terminal in your pocket!
Running Custom Shell Scripts: Take things up a notch by running your own custom shell scripts stored on your PC. Whether it's controlling music playback with mpc or snapping photos with ffmpeg, the possibilities are endless.

As always, I created a simple alias for this whole command, therfore making connecting to my pc as efficient as possible. As an Arch linux user, almost all the daily commands and programs I use are actually my proper shell scripts. So for me, almost all the functionality of my pc can be used with this small command through my phone

Conclusion

By harnessing the power of Termux, SSH, and SSHpass, I've transformed my phone into a remote control for my PC. The convenience and productivity gains are undeniable, and I can't imagine going back. Give it a try, and unlock a whole new world of possibilities!

Additional Resources

How I Capture High-Quality Webcam Photos with a Simple Shell Script

2024-02-16T21:35:58+00:00

Hey there, fellow tech enthusiasts! If you're anything like me, you love finding efficient ways to automate everyday tasks. Today, I'm excited to share with you a nifty shell script I've crafted that allows me to effortlessly capture stunning photos from my webcam.

Purpose

The purpose of this shell script is straightforward: to streamline the process of capturing photos from a webcam and saving them as high-quality JPEG files, all with just a few lines of code.

Prerequisites

Before diving into the magic of this script, ensure you have v4l-utils and ffmpeg installed on your system. These tools are essential for interacting with the webcam and processing the captured video stream.

Script Overview

    

#!/bin/bash

# Check if v4l2-ctl and ffmpeg are installed
if ! command -v v4l2-ctl &> /dev/null || ! command -v ffmpeg &> /dev/null; then
    echo "Please install v4l-utils and ffmpeg using your package manager."
    exit 1
fi

# Get the maximum resolution supported by the camera
resolution=$(v4l2-ctl --list-formats-ext | grep -oP '\d+x\d+' | tail -n 1)

# Set the output file name
output_file="${HOME}/Pictures/photo_$(date +"%Y-%m-%d_%H-%M-%S").jpg"

# Capture photo with the detected maximum resolution
ffmpeg -f video4linux2 -s "$resolution" -i /dev/video0 -q:v 1 -vframes 1 "$output_file" 2>/dev/null

# Check if the photo was captured successfully
if [ $? -eq 0 ]; then
    echo "Photo captured successfully. Saved as $output_file"
    nohup feh "$output_file" </dev/null >/dev/null 2>&1 &
else
    echo "Failed to capture photo."
fi

Let me walk you through how this script works. We'll cover everything from checking for necessary commands to capturing the perfect shot.

Understanding the Script

Checking for Required Commands: We start by verifying the presence of v4l2-ctl and ffmpeg on the system.
Getting Maximum Resolution: Next, we determine the maximum resolution supported by the webcam.
Setting Output File Name: Each photo captured is uniquely named using a timestamp.
Capturing the Photo: Using ffmpeg, we capture a single frame from the webcam at the detected maximum resolution.
Verification: Finally, we check if the capture was successful and provide feedback accordingly.

How to Use the Script

Now, let's put this script to work:

Copy:the script code and save it to a file on your system.
Grant Execution Permissions: Make the script executable with chmod +x script.sh.
Create an Alias: Create an alias for the script using the following command:
```
$ alias capture_photo='/path/to/script.sh'
```
Verify Alias: Check if the alias is created successfully by running:
```
$ which capture_photo
```

Now, you can use the capture_photo alias to execute the script from anywhere in your terminal.

Conclusion

With this simple yet powerful shell script, capturing stunning photos from your webcam has never been easier. Embrace the convenience of automation and let your creativity flow. Give it a try, and don't hesitate to customize it to suit your preferences!

5 Best Linux Distributions for Beginners

2024-01-21T11:41:39+00:00

Hello there! If you're new to Linux and feeling a bit overwhelmed by all the different distributions out there, don't worry - I've got you covered. As someone who's been using Linux for years, I can tell you that there are plenty of beginner-friendly options available that will make your transition from Windows or macOS as smooth as possible.

Ubuntu

If you're looking for a widely-used and well-supported distribution, Ubuntu is an excellent choice. It's user-friendly, has a large community, and is based on Debian. Ubuntu provides a reliable and stable environment, making it suitable for both beginners and experienced users. Plus, it has a Software Center for easy application installation and updates.

Mint

Linux Mint

Personally, I recommend starting with Linux Mint. It's based on Ubuntu, which is one of the most popular distributions out there, but it has a user-friendly interface that's reminiscent of Windows. Plus, it comes with a variety of pre-installed applications, so you won't have to spend too much time searching for software.

MX Linux

If you're looking for something even more lightweight, I'd suggest giving MX Linux a try. It's based on Debian and uses the Xfce desktop environment, which is fast and efficient. MX Linux also has a software manager that makes it easy to install new applications and updates.

Elementary OS

For those who prefer a more modern interface, Elementary OS is a great choice. It's designed to be simple and easy to use, with a beautiful interface that's similar to macOS. Like Mint and MX Linux, it also comes with a variety of pre-installed applications. Elementary OS is considered to be the most beautiful distribution, it has a great file manager similar to that of macOS.

Zorin OS

Zorin OS is another great option for those who are new to Linux and are looking for a Windows-like interface. It's designed to be easy to use for Windows users who are new to Linux, and it comes with a variety of pre-installed applications and a software center that makes it easy to install new software.

Ultimately, the best Linux distribution for you will depend on your personal preferences and needs. My advice would be to try out a few different distributions and see which one you like the best. Linux is all about freedom of choice, so don't be afraid to experiment and find the distribution that works best for you. Good luck and happy exploring!

If you're curious about Linux but not ready to commit, you can also create a bootable USB drive with your chosen distribution and run it in a live environment. This allows you to explore the system without making any changes to your computer's existing setup. It's a great way to test the waters and see if Linux suits your needs before making a permanent switch.

Quranic Wisdom on Your Desktop: Conky Setup Explained

2024-01-18T13:48:46+00:00

Let me take you through the process of creating a unique Conky setup to display Quran verses on your desktop. This involves a set of Python and shell scripts, along with some Conky configuration magic.

1. Reshaping Arabic Text

To begin, I crafted a Python script, reshape_arabic.py, that handles the reshaping of Arabic text. Leveraging the arabic_reshaper and bidi libraries, the script ensures that the Arabic text is correctly displayed and fits neatly within a specified line length.

    

# Install the arabic_reshaper package if you haven't already
# You can install it using: pip install arabic-reshaper
# install bidi using      : pip install python-bidi

import arabic_reshaper
from bidi.algorithm import get_display
import sys

def reshape_and_wrap_arabic_text(text, line_length):
    #arabic_reshaper.delete_harakat=False
    reshaped_text = arabic_reshaper.reshape(text)
    bidi_text = get_display(reshaped_text)

    # Split the text into words
    words = bidi_text.split()

    # Initialize variables
    current_line = ""
    wrapped_lines = []

    # Iterate through words and wrap lines
    for word in words:
        if len(current_line) + len(word) + 1 <= line_length:
            current_line += word + " "
        else:
            wrapped_lines.append(current_line)
            current_line = word + " "

    # Add the last line
    wrapped_lines.append(current_line)

    # Reverse the order of lines to read from bottom up
    wrapped_text = "\n".join(reversed(wrapped_lines))

    return wrapped_text


arabic_text =  sys.argv[1]
wrapped_text = reshape_and_wrap_arabic_text(arabic_text, 100)
print(wrapped_text)

Screenshot 2

2. Fortune and Shell Script Magic

    

#!/bin/bash
#
fortune_data_directory="${HOME}/.i3/conky/conky_quran/quran_fortune/"
python_script="${HOME}/.i3/conky/conky_quran/reshape_arabic.py"

arabic_text="$(fortune "$fortune_data_directory" )"
source "${HOME}/bin/venv/bin/activate"

reshaped_arabic_text=$(python "$python_script" "$arabic_text" )
printf '%s' "$reshaped_arabic_text"

The shell script is the orchestrator of the process. It uses the fortune command to randomly select a Quranic verse from a designated directory. After obtaining the verse, it activates a virtual environment and hands the text to the Python script for reshaping.

3. Crafting the Conky Environment

With the reshaped Arabic text in hand, it's time to showcase it on the desktop using Conky. The following Conky configuration script comes into play, defining the fonts, window properties, colors, and other visual elements. This script transforms the desktop into an elegant canvas for displaying Quran verses.

    

conky.config = {
    use_xft =true,
    font ='Amiri:size=27',
    xftalpha =0.1,
    update_interval =1,
    total_run_times =0,

    own_window =true,
    own_window_type ="conky",
    own_window_type ="override",
    own_window_transparent =true,
    own_window_hints ="undecorated,below,sticky,skip_taskbar,skip_pager",
    own_window_colour ="000000",
    own_window_argb_visual =true,
    own_window_argb_value =255,

    double_buffer =true,
    minimum_width =1265,
    draw_shades =false,
    draw_outline =false,
    border_width = 1,
    draw_borders =false,
    draw_graph_borders =false,
    default_color ="white",
    default_shade_color ="red",
    default_outline_color ="green",
    alignment ="top_middle",
    gap_x =-10,
    gap_y =160,
    no_buffers =true,
    cpu_avg_samples =2,
    net_avg_samples =1,
    override_utf8_locale =true,
    use_spacer ="none",

}

conky.text = [[
    ${execi 20 /home/mosaid/.i3/conky/conky_quran/reshape_arabic.sh }
]]

Screenshot 2

How to Use

To integrate this setup, ensure that the required Python libraries are installed. The Conky configuration is set up to point to the shell script, creating a seamless pipeline that fetches, reshapes, and displays a random Quran verse on your desktop at regular intervals.

You can get all the files from this github repo : Conky Quran with fortune

In Conclusion

This personalized Conky Quran display is not just a functional addition but also a visually pleasing one. By combining the flexibility of Conky with the scripting capabilities of Python, you can bring a touch of elegance and inspiration to your desktop with ever-changing Quranic verses.

Deep Dive: System Architecture Differences - Linux vs. Windows

2024-01-16T20:54:59+00:00

The Inner Workings of Linux System Calls

For the technically inclined, delving into the core of Linux reveals a design philosophy centered around openness and transparency. At the heart of this lies the system call interface, a set of open and documented entry points that enable user applications to communicate directly with the kernel. In the following example, the C program uses the "write" system call to print "Hello, Linux!" to the standard output:

   

// Linux System Call Example
#include <stdio.h>
#include <unistd.h>

int main() {
    write(1, "Hello, Linux!\n", 13);
    return 0;
}

Linux System calls Overview

Windows: Navigating Through Layers

Windows, on the other hand, employs a more intricate and layered architecture. As user applications interact with the operating system, they traverse through several intermediary layers. At the forefront is the Windows API (WinAPI), a comprehensive set of functions and procedures. However, beneath this facade, developers encounter layers such as winntdll, which acts as a bridge between user space and the kernel. Consider the following example showcasing the use of WinAPI in a Windows C program:

    

// Windows WinAPI Example
#include <windows.h>
#include <stdio.h>

int main() {
    MessageBox(NULL, "Hello, Windows!", "Message", MB_OK);
    return 0;
}

Here, the C program utilizes the "MessageBox" function provided by the WinAPI. However, this function is just the tip of the iceberg. Under the hood, it calls a series of other functions and passes through layers such as winntdll. For instance, "MessageBox" may internally call functions like "CreateWindow," which in turn involves more intricate processes. The detailed execution path is encapsulated within the closed layers of the Windows architecture.

Windows Operating System Software Architecture Overview

Linux's System Call Interface: A Programmer's Perspective

From a programming standpoint, the direct communication facilitated by Linux's system call interface offers a programmer unparalleled control and visibility. The absence of excessive intermediary layers streamlines the development process, making it easier to understand and optimize system interactions.

Peering Into the Kernel: A Windows Perspective

In contrast, navigating through Windows' layered architecture requires a keen understanding of the interactions between user space and the Windows Executive. The transition from user space to kernel mode involves traversing through proprietary layers, adding intricacy to the debugging and optimization processes.

Conclusion: Unraveling the Architectural Nuances

In conclusion, the architectural disparities between Linux and Windows reveal themselves in the transparency of Linux's system calls and the layered complexity of Windows. For developers and system architects, choosing between the two involves weighing the advantages of a straightforward, open system against the added complexities of a layered architecture.

Customize Ranger File Manager: Tips and Tricks for Personalizing Your Experience

2023-03-24T17:17:01+00:00

Today, I want to talk about one of my favorite tools for managing files and directories on the command line: Ranger File Manager. As a developer, I spend a lot of time working in the terminal, and I find that using a good file manager can make my life a lot easier. And Ranger is one of the best file managers out there!

One of the things I love about Ranger is how customizable it is. You can tweak pretty much everything about it, from the color scheme and key bindings to the plugins and file preview settings. And this is great, because it means you can tailor Ranger to your exact needs and preferences. For example, I like to use a dark color scheme and map some of the most common commands to single keys, so that I can navigate files quickly and efficiently.

Another thing that makes Ranger so powerful is its support for plugins. There are dozens of plugins available for Ranger, which can add all sorts of functionality to the file manager. Some of my favorite plugins include the one for integrating with Git, which shows me the status of my repositories right in Ranger, and the one for previewing images and videos, which lets me quickly preview media files without having to open them in an external program.

Ranger File Manager: image preview

Ranger File Manager: file preview

To add your custom commands to ranger, all you have to do is add it to "commands.py" file in ~/.config/ranger directory. here is my own commands.py file, to use it you must have the programs it uses installed like fzf

   

# This is a sample commands.py.  You can add your own commands here.
#
# Please refer to commands_full.py for all the default commands and a complete
# documentation.  Do NOT add them all here, or you may end up with defunct
# commands when upgrading ranger.

# A simple command for demonstration purposes follows.
# -----------------------------------------------------------------------------

from __future__ import absolute_import, division, print_function

# You can import any python module as needed.
import os

# You always need to import ranger.api.commands here to get the Command class:
from ranger.api.commands import Command


# Any class that is a subclass of "Command" will be integrated into ranger as a
# command.  Try typing ":my_edit<ENTER>" in ranger!
class my_edit(Command):
    # The so-called doc-string of the class will be visible in the built-in
    # help that is accessible by typing "?c" inside ranger.
    """:my_edit <filename>

    A sample command for demonstration purposes that opens a file in an editor.
    """

    # The execute method is called when you run this command in ranger.
    def execute(self):
        # self.arg(1) is the first (space-separated) argument to the function.
        # This way you can write ":my_edit somefilename<ENTER>".
        if self.arg(1):
            # self.rest(1) contains self.arg(1) and everything that follows
            target_filename = self.rest(1)
        else:
            # self.fm is a ranger.core.filemanager.FileManager object and gives
            # you access to internals of ranger.
            # self.fm.thisfile is a ranger.container.file.File object and is a
            # reference to the currently selected file.
            target_filename = self.fm.thisfile.path

        # This is a generic function to print text in ranger.
        self.fm.notify("Let's edit the file " + target_filename + "!")

        # Using bad=True in fm.notify allows you to print error messages:
        if not os.path.exists(target_filename):
            self.fm.notify("The given file does not exist!", bad=True)
            return

        # This executes a function from ranger.core.acitons, a module with a
        # variety of subroutines that can help you construct commands.
        # Check out the source, or run "pydoc ranger.core.actions" for a list.
        self.fm.edit_file(target_filename)

    # The tab method is called when you press tab, and should return a list of
    # suggestions that the user will tab through.
    # tabnum is 1 for <TAB> and -1 for <S-TAB> by default
    def tab(self, tabnum):
        # This is a generic tab-completion function that iterates through the
        # content of the current directory.
        return self._tab_directory_content()


class terminal(Command):
    """
    :terminal

    Open new terminal split in the current directory.
    """

    def execute(self):
        import os
        from ranger.ext.get_executables import get_executables

        command = "lxterminal"
        self.fm.run(command, flags="f")


# https://github.com/ranger/ranger/wiki/Integrating-File-Search-with-fzf
# Now, simply bind this function to a key, by adding this to your ~/.config/ranger/rc.conf:
# map <C-f> fzf_select
class fzf_select(Command):
    """
    :fzf_select

    Find a file using fzf.

    With a prefix argument select only directories.

    See: https://github.com/junegunn/fzf
    """

    def execute(self):
        import subprocess

        if self.quantifier:
            # match only directories
            command = "find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
            -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
        else:
            # match files and directories
            command = "find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
            -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
        fzf = self.fm.execute_command(command, stdout=subprocess.PIPE)
        stdout, stderr = fzf.communicate()
        if fzf.returncode == 0:
            fzf_file = os.path.abspath(stdout.decode("utf-8").rstrip("\n"))
            if os.path.isdir(fzf_file):
                self.fm.cd(fzf_file)
            else:
                self.fm.select_file(fzf_file)


# fzf_locate
class fzf_locate(Command):
    """
    :fzf_locate

    Find a file using fzf.

    With a prefix argument select only directories.

    See: https://github.com/junegunn/fzf
    """

    def execute(self):
        import subprocess

        if self.quantifier:
            command = "locate home media | fzf -e -i"
        else:
            command = "locate home media | fzf -e -i"
        fzf = self.fm.execute_command(command, stdout=subprocess.PIPE)
        stdout, stderr = fzf.communicate()
        if fzf.returncode == 0:
            fzf_file = os.path.abspath(stdout.decode("utf-8").rstrip("\n"))
            if os.path.isdir(fzf_file):
                self.fm.cd(fzf_file)
            else:
                self.fm.select_file(fzf_file)


# fzf_fasd - Fasd + Fzf + Ranger (Interactive Style)
class fzf_fasd(Command):
    """
    :fzf_fasd

    Jump to a file or folder using Fasd and fzf

    URL: https://github.com/clvv/fasd
    URL: https://github.com/junegunn/fzf
    """

    def execute(self):
        import subprocess

        if self.quantifier:
            command = "fasd | fzf -e -i --tac --no-sort | awk '{print $2}'"
        else:
            command = "fasd | fzf -e -i --tac --no-sort | awk '{print $2}'"
        fzf = self.fm.execute_command(command, stdout=subprocess.PIPE)
        stdout, stderr = fzf.communicate()
        if fzf.returncode == 0:
            fzf_file = os.path.abspath(stdout.decode("utf-8").rstrip("\n"))
            if os.path.isdir(fzf_file):
                self.fm.cd(fzf_file)
            else:
                self.fm.select_file(fzf_file)


# Fasd with ranger (Command Line Style)
# https://github.com/ranger/ranger/wiki/Commands


class fasd(Command):
    """
    :fasd

    Jump to directory using fasd
    URL: https://github.com/clvv/fasd
    """

    def execute(self):
        import subprocess

        arg = self.rest(1)
        if arg:
            directory = subprocess.check_output(
                ["fasd", "-d"] + arg.split(), universal_newlines=True
            ).strip()
            self.fm.cd(directory)


from collections import deque

fd_deq = deque()


class fd_search(Command):
    """
    :fd_search [-d<depth>] <query>

    Executes "fd -d<depth> <query>" in the current directory and focuses the
    first match. <depth> defaults to 1, i.e. only the contents of the current
    directory.
    """

    def execute(self):
        import subprocess
        from ranger.ext.get_executables import get_executables

        if not "fd" in get_executables():
            self.fm.notify("Couldn't find fd on the PATH.", bad=True)
            return
        if self.arg(1):
            if self.arg(1)[:2] == "-d":
                depth = self.arg(1)
                target = self.rest(2)
            else:
                depth = "-d1"
                target = self.rest(1)
        else:
            self.fm.notify(":fd_search needs a query.", bad=True)
            return

        # For convenience, change which dict is used as result_sep to change
        # fd's behavior from splitting results by \0, which allows for newlines
        # in your filenames to splitting results by \n, which allows for \0 in
        # filenames.
        null_sep = {"arg": "-0", "split": "\0"}
        nl_sep = {"arg": "", "split": "\n"}
        result_sep = null_sep

        process = subprocess.Popen(
            ["fd", result_sep["arg"], depth, target],
            universal_newlines=True,
            stdout=subprocess.PIPE,
        )
        (search_results, _err) = process.communicate()
        global fd_deq
        fd_deq = deque(
            (
                self.fm.thisdir.path + os.sep + rel
                for rel in sorted(
                    search_results.split(result_sep["split"]), key=str.lower
                )
                if rel != ""
            )
        )
        if len(fd_deq) > 0:
            self.fm.select_file(fd_deq[0])


class fd_next(Command):
    """
    :fd_next

    Selects the next match from the last :fd_search.
    """

    def execute(self):
        if len(fd_deq) > 1:
            fd_deq.rotate(-1)  # rotate left
            self.fm.select_file(fd_deq[0])
        elif len(fd_deq) == 1:
            self.fm.select_file(fd_deq[0])


class fd_prev(Command):
    """
    :fd_prev

    Selects the next match from the last :fd_search.
    """

    def execute(self):
        if len(fd_deq) > 1:
            fd_deq.rotate(1)  # rotate right
            self.fm.select_file(fd_deq[0])
        elif len(fd_deq) == 1:
            self.fm.select_file(fd_deq[0])

But perhaps the best thing about Ranger is how much it can streamline your workflow. With Ranger, you can move, copy, delete, rename, and preview files and directories all from the command line. This can save you a lot of time and effort, especially if you're working with a lot of files. And because Ranger is so customizable, you can set it up in a way that feels natural and intuitive to you, which can help you work more efficiently and with less frustration.

Here is the shell script "scope.sh" file that is used by ranger fo previewing files and directories

   

#!/usr/bin/env bash

set -o noclobber -o noglob -o nounset -o pipefail
IFS=$'\n'

# If the option `use_preview_script` is set to `true`,
# then this script will be called and its output will be displayed in ranger.
# ANSI color codes are supported.
# STDIN is disabled, so interactive scripts won't work properly

# This script is considered a configuration file and must be updated manually.
# It will be left untouched if you upgrade ranger.

# Meanings of exit codes:
# code | meaning    | action of ranger
# -----+------------+-------------------------------------------
# 0    | success    | Display stdout as preview
# 1    | no preview | Display no preview at all
# 2    | plain text | Display the plain content of the file
# 3    | fix width  | Don't reload when width changes
# 4    | fix height | Don't reload when height changes
# 5    | fix both   | Don't ever reload
# 6    | image      | Display the image `$IMAGE_CACHE_PATH` points to as an image preview
# 7    | image      | Display the file directly as an image

# Script arguments
FILE_PATH="${1}"         # Full path of the highlighted file
PV_WIDTH="${2}"          # Width of the preview pane (number of fitting characters)
PV_HEIGHT="${3}"         # Height of the preview pane (number of fitting characters)
IMAGE_CACHE_PATH="${4}"  # Full path that should be used to cache image preview
PV_IMAGE_ENABLED="${5}"  # 'True' if image previews are enabled, 'False' otherwise.

FILE_EXTENSION="${FILE_PATH##*.}"
FILE_EXTENSION_LOWER=$(echo ${FILE_EXTENSION} | tr '[:upper:]' '[:lower:]')

# Settings
HIGHLIGHT_SIZE_MAX=262143  # 256KiB
HIGHLIGHT_TABWIDTH=8
HIGHLIGHT_STYLE='pablo'
PYGMENTIZE_STYLE='autumn'


handle_extension() {
    case "${FILE_EXTENSION_LOWER}" in
        # Archive
        a|ace|alz|arc|arj|bz|bz2|cab|cpio|deb|gz|jar|lha|lz|lzh|lzma|lzo|\
        rpm|rz|t7z|tar|tbz|tbz2|tgz|tlz|txz|tZ|tzo|war|xpi|xz|Z|zip)
            atool --list -- "${FILE_PATH}" && exit 5
            bsdtar --list --file "${FILE_PATH}" && exit 5
            exit 1;;
        rar)
            # Avoid password prompt by providing empty password
            unrar lt -p- -- "${FILE_PATH}" && exit 5
            exit 1;;
        djvu)
            exit 1 ;;
        7z)
            # Avoid password prompt by providing empty password
            7z l -p -- "${FILE_PATH}" && exit 5
            exit 1;;

        # PDF
        #pdf)
            # Preview as text conversion
            #pdftotext -l 10 -nopgbrk -q -- "${FILE_PATH}" - && exit 5
        #evince-thumbnailer -s 400 "${FILE_PATH}" && exit 5
        #try pdftoppm -jpeg -singlefile "$path" "${cached//.jpg}" && exit 5
        #exiftool "${FILE_PATH}" && exit 5
            #exit 1;;

        # BitTorrent
        torrent)
            transmission-show -- "${FILE_PATH}" && exit 5
            exit 1;;

        # OpenDocument
        odt|ods|odp|sxw)
            # Preview as text conversion
            odt2txt "${FILE_PATH}" && exit 5
            exit 1;;

        mkv)
             # Thumbnail
             ffmpegthumbnailer -i "${FILE_PATH}" -o "${IMAGE_CACHE_PATH}" -s 0 && exit 6
             exit 1;;
        # HTML
        htm|html|xhtml)
            # Preview as text conversion
            w3m -dump "${FILE_PATH}" && exit 5
            lynx -dump -- "${FILE_PATH}" && exit 5
            elinks -dump "${FILE_PATH}" && exit 5
            ;; # Continue with next handler on failure
    esac
}

handle_image() {
    local mimetype="${1}"
    case "${mimetype}" in
        # SVG
        # image/svg+xml)
        #     convert "${FILE_PATH}" "${IMAGE_CACHE_PATH}" && exit 6
        #     exit 1;;

        # Image
        image/vnd.djvu)
            exit 1;;
        image/*)
            local orientation
            orientation="$( identify -format '%[EXIF:Orientation]\n' -- "${FILE_PATH}" )"
            # If orientation data is present and the image actually
            # needs rotating ("1" means no rotation)...
            if [[ -n "$orientation" && "$orientation" != 1 ]]; then
                # ...auto-rotate the image according to the EXIF data.
                convert -- "${FILE_PATH}" -auto-orient "${IMAGE_CACHE_PATH}" && exit 6
            fi

            # `w3mimgdisplay` will be called for all images (unless overriden as above),
            # but might fail for unsupported types.
            exit 7;;

        # Video
          video/*)
             # Thumbnail
             ffmpegthumbnailer -i "${FILE_PATH}" -o "${IMAGE_CACHE_PATH}" -s 0 && exit 6
             exit 1;;
        # PDF
         application/pdf)
             pdftoppm -f 1 -l 1 \
                      -scale-to-x 1920 \
                      -scale-to-y -1 \
                      -singlefile \
                      -jpeg -tiffcompression jpeg \
                      -- "${FILE_PATH}" "${IMAGE_CACHE_PATH%.*}" \
                 && exit 6 || exit 1;;
    esac
}

handle_mime() {
    local mimetype="${1}"
    case "${mimetype}" in
        # Text
        text/* | */xml)
            # Syntax highlight
            if [[ "$( stat --printf='%s' -- "${FILE_PATH}" )" -gt "${HIGHLIGHT_SIZE_MAX}" ]]; then
                exit 2
            fi
            if [[ "$( tput colors )" -ge 256 ]]; then
                local pygmentize_format='terminal256'
                local highlight_format='xterm256'
            else
                local pygmentize_format='terminal'
                local highlight_format='ansi'
            fi
            highlight --replace-tabs="${HIGHLIGHT_TABWIDTH}" --out-format="${highlight_format}" \
                --style="${HIGHLIGHT_STYLE}" --force -- "${FILE_PATH}" && exit 5
            # pygmentize -f "${pygmentize_format}" -O "style=${PYGMENTIZE_STYLE}" -- "${FILE_PATH}" && exit 5
            exit 2;;

        # Image
        image/vnd.djvu)
                exit 1;;
        image/*)
            # Preview as text conversion
            # img2txt --gamma=0.6 --width="${PV_WIDTH}" -- "${FILE_PATH}" && exit 4
            exiftool "${FILE_PATH}" && exit 5
            exit 1;;

        # Video and audio
        video/* | audio/*)
            mediainfo "${FILE_PATH}" && exit 5
            exiftool "${FILE_PATH}" && exit 5
            exit 1;;
    esac
}

handle_fallback() {
    echo '----- File Type Classification -----' && file --dereference --brief -- "${FILE_PATH}" && exit 5
    exit 1
}


MIMETYPE="$( file --dereference --brief --mime-type -- "${FILE_PATH}" )"
if [[ "${PV_IMAGE_ENABLED}" == 'True' ]]; then
    handle_image "${MIMETYPE}"
fi
handle_extension
handle_mime "${MIMETYPE}"
handle_fallback

exit 1

So if you're a command-line user looking for a powerful and flexible file manager, I definitely recommend checking out Ranger. It may take a bit of time to set up and configure to your liking, but once you do, it can really make your life a lot easier. Trust me, I've been using it for years, and I can't imagine working without it!

How to edit images in the terminal

2023-03-15T20:28:56+00:00

Simple answer: the convert command from imagemagick package

The convert command is a powerful tool that comes with the ImageMagick library, which can be used to manipulate images from the command line. This tutorial will cover some of the most common use cases of the convert command.

Installing convert

   

# Arch based disro
sudo pacman -S imagemagick
# Debian Based distros
sudo apt install imagemagick
# to check if the install was successfull
convert -version

Resizing an image:

To resize an image, you can use the following syntax:

   

convert input_image.jpg -resize 50% output_image.jpg
convert input_image.jpg -resize 500x500 output_image.jpg

This will resize the input image to 50% of its original size and save the resized image as "output_image.jpg". The second command will resize it to 500x500, this is my daily command as it helps me create small thumbnails. keep in mind that you should be mindful of the aspect ration of the image I use 500x500 because the input image is square

Cropping an image:

To crop an image, you can use the following syntax:

   

convert input_image.jpg -gravity South -chop x200 output_image.jpg
convert input_image.jpg -crop 500x500+100+100 output_image.jpg

The first command will remove 200px from the bottom of the input image.
The second command will crop a 500x500 pixel square from the input image, starting at coordinates (100, 100) and save the cropped image as "output_image.jpg".

Rotating an image:

To rotate an image, you can use the following syntax:

   

convert input_image.jpg -rotate 90 output_image.jpg

This will rotate the input image by 90 degrees clockwise and save the rotated image as "output_image.jpg".

Converting image format:

To convert an image from one format to another, you can use the following syntax:

   

convert input_image.png output_image.jpg

This will convert the input image from PNG format to JPEG format and save the converted image as "output_image.jpg".

Adding a border to an image:

To add a border to an image, you can use the following syntax:

   

convert input_image.jpg -bordercolor black -border 20 output_image.jpg

This will add a black border with a width of 20 pixels to the input image and save the bordered image as "output_image.jpg".

Adding a watermark to an image:

To add a watermark to an image, you can use the following syntax:

   

convert input_image.jpg -gravity center -pointsize 30 -fill white -annotate +0+0 "watermark" output_image.jpg

This will add a white watermark with the text "watermark" to the center of the input image and save the watermarked image as "output_image.jpg".

Applying a filter to an image:

To apply a filter to an image, you can use the following syntax:

   

convert input_image.jpg -colorspace Gray output_image.jpg

This will apply a grayscale filter to the input image and save the filtered image as "output_image.jpg".

These are just some of the most common use cases of the convert command. The convert command has many other options and features, which can be explored by referring to the ImageMagick documentation.

Have you Heard Of Gecholinux ?

2023-02-25T20:26:29+00:00

Gecholinux is a Linux distribution that is based on openSUSE operating system. It is designed to be easy to use and lightweight, making it a good option for older or less powerful computers. As someone who has used various Linux distributions over the years, I found Gecholinux to be a solid choice for those looking for a simple and efficient operating system.

One of the things I appreciate about Gecholinux is its minimalistic approach. The distribution comes with only the essential software pre-installed, which helps keep the system fast and responsive. This is a refreshing change from other Linux distributions that come with a plethora of programs that most users will never use.

Gecholinux also has a user-friendly interface, making it easy to navigate for those who may be new to Linux. The desktop environment is clean and simple, with a taskbar and menu that are easy to access. The default applications that come with the distribution, such as the file manager and web browser, are intuitive and easy to use.

Another feature of Gecholinux that sets it apart is its focus on privacy and security. The distribution includes several privacy-focused applications, such as the Tor Browser and the I2P network, that allow users to browse the internet anonymously. Additionally, Gecholinux comes with built-in encryption tools that help protect sensitive data.

Here is a technical sheet of Gecholinux:

Desktop Environment:	Xfce
File Manager:	Thunar
Other Default Packages in Gecholinux:	Firefox, LibreOffice, GIMP, VLC, Tor Browser, I2P, VeraCrypt

Gecholinux File Manager And Desktop Environment

for more infomation, check Gecholinux Home page

One downside of Gecholinux is that it may not be the best choice for power users or those who require a lot of customization options. The distribution is designed to be lightweight and simple, so it may not have all the bells and whistles that some users may be looking for.

How to Check Your Linux Distribution and Version

2023-02-21T13:59:52+00:00

If you're a Linux user, it's important to know which distribution and version of Linux you're running. This information can be useful when troubleshooting issues or installing software that requires a specific version of Linux.

When people refer to Linux, they are usually referring to a Linux distribution. Strictly speaking, Linux is a kernel, the core component of the operating system that, simply put, acts just like a bridge between the software applications and the hardware. A Linux distribution is an operating system made from a Linux kernel, GNU tools and libraries, and software collections. Usually, Linux distributions include desktop environments, package management system, and a set of preinstalled applications.

Some of the most popular Linux distributions are:

Debian
Red Hat
Ubuntu
Arch Linux
Fedora
CentOS
Kali Linux
OpenSUSE
Linux Mint

When you log in to a Linux system for the first time, before doing any work, it is always a good idea to check what version of Linux is running on the machine. For example, determining the Linux distribution can help you figure out what package manager you should use to install new packages.

Here are a few ways to check which distribution and version of Linux you're running:

1. Use the lsb_release Command

The lsb_release command is a simple and easy way to check your Linux distribution and version. To use it, open a terminal window and type the following command:


lsb_release -a

This will display information about your Linux distribution, including the distribution ID, release number, and codename. Here's an example output:


Distributor ID: Ubuntu
Description: Ubuntu 20.04.3 LTS
Release: 20.04
Codename: focal

2. check /etc/os-release file

The /etc/os-release file contains operating system identification data, including information about the distribution. This file is part of the systemd package and should be present on all system running systemd.

To view the contents of the os-release file, use either cat or less :


cat /etc/os-release

or you can check for anyfile that has "ease" at the end of its name:


cat /etc/*ease

The output should look something like below:


PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
NAME="Debian GNU/Linux"
VERSION_ID="9"
VERSION="9 (stretch)"
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

3. Check the /etc/issue File

Another way to check your Linux distribution and version is to look at the contents of the /etc/issue file. This file contains information about your Linux distribution and version, as well as the kernel version.

To view the contents of the /etc/issue file, open a terminal window and type the following command:


cat /etc/issue

Here's an example output:


Ubuntu 20.04.3 LTS \n \l

4. Use the hostnamectl Command

The hostnamectl command can also be used to check your Linux distribution and version. This command displays information about your system, including the operating system and kernel version.

To use the hostnamectl command, open a terminal window and type the following command:


hostnamectl

Here's an example output:


 Static hostname: ubuntu
Icon name: computer-laptop
Chassis: laptop
Machine ID: 1234567890abcdef
Boot ID: 1234567890abcdef
Operating System: Ubuntu 20.04.3 LTS
Kernel: Linux 5.11.0-38-generic
Architecture: x86-64

5. Using the Graphical Interface

If you are using a Linux distribution with a graphical interface, you can usually check your distribution and version from the settings or system information panel. The exact location of this information may vary depending on your distribution.

Conclusion

Knowing which Linux distribution and version you're running is an important piece of information for Linux users. With the above methods, you can easily check your Linux distribution and version in just a few steps.

Rofi - A Window Switcher, Application Launcher, SSH Dialog, dmenu Replacement and More

2023-02-20T17:31:59+00:00

Installation

Rofi is available in most Linux distributions' official repositories. To install it, open your terminal and type the following command:

sudo apt-get install rofi

If you are using a different package manager, replace apt-get with the appropriate command for your system.

Alternatively, you can download the source code from the official Rofi website and build it manually.

Basic Usage

Application Launcher

One of the most common uses of Rofi is as an application launcher. To launch Rofi, open your terminal and type the following command:

rofi -show run

This will open the Rofi launcher with a list of installed applications. You can use the arrow keys to navigate the list and press Enter to launch the selected application.

You can also search for an application by typing its name in the search bar at the top of the Rofi window. Rofi will filter the list of applications based on your search query.

Window Switcher

Rofi can also be used as a window switcher. To launch Rofi in window switcher mode, type the following command in your terminal:

rofi -show window

This will open the Rofi window switcher, which will display a list of currently open windows. You can use the arrow keys to navigate the list and press Enter to switch to the selected window.

SSH Dialog

Rofi also provides an SSH dialog, which allows you to quickly connect to remote servers using SSH. To launch the SSH dialog, type the following command in your terminal:

rofi -show ssh

This will open the Rofi SSH dialog, which will prompt you to enter the hostname or IP address of the server you want to connect to. Once you enter the server information, press Enter to initiate the SSH connection.

dmenu Replacement

Rofi can also be used as a replacement for the dmenu utility, which is used in many Linux window managers to launch applications and perform other tasks. To launch Rofi as a dmenu replacement, type the following command in your terminal:

rofi -dmenu

This will open the Rofi dmenu, which will display a list of items based on the input you provide. You can use the arrow keys to navigate the list and press Enter to select the item.

Customization

Rofi provides many customization options that allow you to tailor its behavior and appearance to your needs. You can customize Rofi by editing its configuration file, which is located at ~/.config/rofi/config.rasi.

Some of the things you can customize in the Rofi configuration file include:

The color scheme
The font
The keybindings
The behavior of each mode (application launcher, window switcher, SSH dialog, dmenu replacement)

For example, to change the color scheme of Rofi, you can add the following lines to the configuration file:

    

configuration {
  /* ... */
  theme: "my-theme";
  /* ... */
}

# Colors for my-theme
* {
  background-color: #282828;
  text-color: #ebdbb2;
  selected-background-color: #458588;
  selected-text-color: #ebdbb2;
}

This will set the theme to "my-theme" and define the colors for the background, text, selected background, and selected text.

You can also create custom keybindings for Rofi by adding the following lines to the configuration file:

    

configuration {
  /* ... */
  key-ctrl-t: "spawn urxvt";
  key-super-d: "spawn rofi -show run";
  /* ... */
}

This will create two custom keybindings: Ctrl + T will launch the urxvt terminal emulator, and Super + D will launch the Rofi application launcher.

My Personal config

In my home config directory: ~/.config/rofi I have two files; the config file config.rasi and the theme file Monokai.rasi

config.rasi

    

configuration {
    modi: "window,run,drun,combi";
    font: "Awesome 11";
    location: 0;
    yoffset: 20;
    xoffset: 0;
    fixed-num-lines: false;
    show-icons: true;
    terminal: "lxterminal";
    ssh-client: "ssh";
    ssh-command: "{terminal} -e {ssh-client} {host}";
    run-command: "{cmd}";
    run-list-command: "";
    run-shell-command: "{terminal} -e {cmd}";
    window-command: "xkill -id {window}";
    disable-history: false;
    case-sensitive: false;
    cycle: true;
    sidebar-mode: false;
    eh: 1;
    auto-select: false;
    parse-hosts: false;
    parse-known-hosts: true;
    combi-modi: "window,drun";
    tokenize: true;
    m: "-1";
    filter: "";
    dpi: -1;
    threads: 1;
    scroll-method: 0;
}
@theme "Monokai"

Monokai.rasi, the theme file which I don't remember where I got it from

    

/**
 * ROFI Color theme
 * User: milouse
 * Copyright: Étienne Deparis
 */

* {
    selected-normal-foreground:  rgba ( 0, 0, 0, 100 % );
    foreground:                  rgba ( 248, 248, 242, 100 % );
    normal-foreground:           @foreground;
    alternate-normal-background: rgba ( 39, 40, 34, 0 % );
    red:                         rgba ( 220, 50, 47, 100 % );
    selected-urgent-foreground:  rgba ( 248, 248, 242, 100 % );
    blue:                        rgba ( 38, 139, 210, 100 % );
    urgent-foreground:           rgba ( 249, 38, 114, 100 % );
    alternate-urgent-background: rgba ( 39, 40, 34, 0 % );
    active-foreground:           rgba ( 166, 226, 42, 100 % );
    lightbg:                     rgba ( 238, 232, 213, 100 % );
    selected-active-foreground:  rgba ( 166, 226, 42, 100 % );
    alternate-active-background: rgba ( 39, 40, 34, 0 % );
    background:                  rgba ( 39, 40, 34, 93 % );
    bordercolor:                 rgba ( 0, 43, 54, 100 % );
    alternate-normal-foreground: @foreground;
    normal-background:           rgba ( 39, 40, 34, 0 % );
    lightfg:                     rgba ( 88, 104, 117, 100 % );
    selected-normal-background:  rgba ( 248, 248, 248, 100 % );
    border-color:                @foreground;
    spacing:                     2;
    separatorcolor:              rgba ( 230, 219, 116, 100 % );
    urgent-background:           rgba ( 39, 40, 34, 0 % );
    selected-urgent-background:  rgba ( 249, 38, 114, 100 % );
    alternate-urgent-foreground: @urgent-foreground;
    background-color:            rgba ( 0, 0, 0, 0 % );
    alternate-active-foreground: @active-foreground;
    active-background:           rgba ( 39, 40, 34, 0 % );
    selected-active-background:  rgba ( 20, 20, 17, 100 % );
}
window {
    background-color: @background;
    border:           1;
    padding:          5;
}
mainbox {
    border:  0;
    padding: 0;
}
message {
    border:       2px 0px 0px ;
    border-color: @separatorcolor;
    padding:      1px ;
}
textbox {
    text-color: @foreground;
}
listview {
    fixed-height: 0;
    border:       2px 0px 0px ;
    border-color: @separatorcolor;
    spacing:      2px ;
    scrollbar:    true;
    padding:      2px 0px 0px ;
}
element {
    border:  0;
    padding: 1px ;
}
element-text {
    background-color: inherit;
    text-color:       inherit;
}
element.normal.normal {
    background-color: @normal-background;
    text-color:       @normal-foreground;
}
element.normal.urgent {
    background-color: @urgent-background;
    text-color:       @urgent-foreground;
}
element.normal.active {
    background-color: @active-background;
    text-color:       @active-foreground;
}
element.selected.normal {
    background-color: @selected-normal-background;
    text-color:       @selected-normal-foreground;
}
element.selected.urgent {
    background-color: @selected-urgent-background;
    text-color:       @selected-urgent-foreground;
}
element.selected.active {
    background-color: @selected-active-background;
    text-color:       @selected-active-foreground;
}
element.alternate.normal {
    background-color: @alternate-normal-background;
    text-color:       @alternate-normal-foreground;
}
element.alternate.urgent {
    background-color: @alternate-urgent-background;
    text-color:       @alternate-urgent-foreground;
}
element.alternate.active {
    background-color: @alternate-active-background;
    text-color:       @alternate-active-foreground;
}
scrollbar {
    width:        4px ;
    border:       0;
    handle-width: 8px ;
    padding:      0;
}
mode-switcher {
    border:       2px 0px 0px ;
    border-color: @separatorcolor;
}
button.selected {
    background-color: @selected-normal-background;
    text-color:       @selected-normal-foreground;
}
inputbar {
    spacing:    0;
    text-color: @normal-foreground;
    padding:    1px ;
}
case-indicator {
    spacing:    0;
    text-color: @normal-foreground;
}
entry {
    spacing:    0;
    text-color: @normal-foreground;
}
prompt {
    spacing:    0;
    text-color: @normal-foreground;
}
inputbar {
    children:   [ prompt,textbox-prompt-colon,entry,case-indicator ];
}
textbox-prompt-colon {
    expand:     false;
    str:        ":";
    margin:     0px 0.3em 0em 0em ;
    text-color: @normal-foreground;
}

Conclusion

Rofi is a versatile and lightweight application launcher, window switcher, SSH dialog, and dmenu replacement for Linux systems. It provides a fast and efficient way to launch applications, switch between windows, and perform a variety of other tasks. With its extensive customization options, you can tailor Rofi to your needs and preferences. Try it out and see how it can improve your workflow!

Linux 6.3 update will bring hardware Noise «hwnoise» Tool

2023-02-20T15:40:18+00:00

The Linux 6.3 update includes various enhancements and improvements, including updates to the tracing subsystem. One of the significant additions to the kernel source tree is the "hwnoise" tool, which was developed by Daniel Bristot de Oliveira over the past few months.

The hwnoise tool provides a way to monitor and quantify hardware noise in the system. It relies on the operating system noise tracer (osnoise) and displays a summary of the noise attributed to hardware. The tool works by running with interrupts disabled, which allows it to focus on non-maskable interrupts (NMIs) and hardware-related noise.

The hwnoise tool offers features similar to the osnoise tracer, which is used to monitor system noise. However, hwnoise is designed to focus only on hardware noise and provides a more detailed view of the noise generated by hardware components in the system.

An output example of hwnoise

Overall, the hwnoise tool provides a valuable addition to the Linux kernel source tree for those interested in monitoring and analyzing hardware noise. Its development underscores the ongoing efforts to enhance the performance and functionality of the Linux operating system.

More details on the hwnoise tool can be found here: Official tracing, probes and ftrace repo

fstab: Automounting NTFS partitions

2023-02-19T19:55:21+00:00

Automounting NTFS partitions in Linux using fstab

NTFS is a proprietary file system used by Microsoft Windows operating systems. Linux can read and write NTFS partitions using the ntfs-3g driver. This article explains how to automount NTFS partitions in Linux using fstab.

What is fstab?

The /etc/fstab file is a configuration file that contains information about file systems that are mounted during the boot process. Each line in the file represents a file system that needs to be mounted. fstab is used to configure the automounting of file systems in Linux.

Automounting NTFS partitions using fstab

Step 1: Find the device name and UUID of the NTFS partition

To automount an NTFS partition, you need to know the device name and UUID of the partition. You can use the following command to find the device name and UUID:

    

sudo blkid

This command will display a list of all the available partitions on your system, along with their device names and UUIDs. Find the device name and UUID of the NTFS partition that you want to automount.

Step 2: Create a mount point

You need to create a mount point for the NTFS partition. A mount point is a directory where the partition will be mounted. You can create a mount point in the /mnt directory using the following command:

    

sudo mkdir /mnt/ntfs

Step 3: Edit the fstab file

Open the /etc/fstab file in a text editor using the following command:

    

sudo vim /etc/fstab

Add the following line to the end of the file:

    

UUID=<UUID> /mnt/ntfs ntfs-3g defaults 0 0

Replace <UUID> with the UUID of the NTFS partition that you found in step 1. The ntfs-3g option specifies that the ntfs-3g driver should be used to mount the partition. The defaults option specifies the default mount options for the file system.

Save and close the file.

Step 4: Test the configuration

To test the fstab configuration, you can either reboot your system or manually mount the partition using the following command:

    

sudo mount -a

This command will mount all file systems specified in the /etc/fstab file.

You can verify that the partition is mounted by running the mount command:

    

mount | grep /mnt/ntfs

This command should display the mount point and the file system type.

Permission and ownership problems

Sometimes automounting an NTFS partition in Linux using fstab can result in permission and ownership problems. This is because NTFS partitions are typically formatted and used with Windows operating systems, which have different permissions and ownership models than Linux.

To avoid these issues, you can use the uid and gid options in the fstab configuration to specify the user and group ownership of the mounted partition. You can also use the umask option to set the default permissions for the files and directories on the partition.

For example, you can add the following line to the /etc/fstab file to automount an NTFS partition with read and write access for the current user, while setting the default permissions to 644 for files and 755 for directories:

    

UUID=<UUID> /mnt/ntfs ntfs-3g defaults,uid=<user_id>,gid=<group_id>,umask=022 0 0

Replace <UUID> with the UUID of the NTFS partition, <user_id> with the user ID of the current user, and <group_id> with the group ID of the group that should own the files on the partition.

The umask=022 option sets the default permissions for files to 644 (read and write for the owner, read-only for others) and for directories to 755 (read, write, and execute for the owner, and read and execute for others).

Note that the actual values of uid and gid depend on your system configuration. You can find the user and group IDs by running the id command in the terminal.

By using these options, you can avoid permission and ownership problems when automounting NTFS partitions in Linux using fstab.

Conclusion

Automounting NTFS partitions in Linux using fstab is a simple and straightforward process. By following the steps outlined in this article, you can easily configure your system to automount NTFS partitions during the boot process.

Wine 8.2 Released With More Improvements For Running Windows Apps/Games On Linux

2023-02-18T18:38:09+00:00

Wine 8.2 is the second bi-weekly development release of the new series, following the stable release of Wine 8.0 in late January and the release of Wine 8.1, which began the new development series.

The release of Wine 8.2 continues work on the WoW64 support, which allows 32-bit Portable Executable (PE) modules to call 64-bit Unix libraries, ultimately letting 32-bit Windows applications run without requiring 32-bit Unix libraries. The debug information has been enhanced when operating in WoW64 mode, further improving the support.

Another change in Wine 8.2 is the use of monitor EDID information for querying display names. There are also other changes in the release.

New features and improvements:

Better debug information in Wow64 mode.
Wow64 thunks in the WPCAP library.
Indeo IV50 codec support.
Monitor names set from EDID data.

There are 22 known bug fixes in Wine 8.2, including fixes for software like VBScript and games like GOG Heroes of Might and Magic IV, The Void, and other Windows games. more at : WineHQ

If you're running a Debian or Debian-based distribution, such as Ubuntu or Mint, you can install Wine 8.2 by adding the official WineHQ repository and installing it through the package manager. Arch Linux users can also install Wine 8.2 from the official Arch User Repository (AUR) using their preferred AUR helper, such as yay or pacaur. Keep in mind that while Wine has made significant progress in recent years, it may not be able to run all Windows applications flawlessly. However, for those looking to run specific Windows programs or games on Linux, Wine remains an invaluable tool.

My Personalized Dmenu Launcher

2023-02-16T15:26:00+00:00

My personalized dmenu launcher is a convenient tool that allows me to quickly launch frequently used programs. The launcher gives priority to programs that are frequently used, making them appear first in the dmenu list. Each time a program is executed, its usage is incremented in a SQLite database, ensuring that it will appear at the top of the list in the future.

Usage

There are three ways to use the launcher:

launcher.sh update: Updates the launcher database with the latest program information. This command should be run whenever new programs are installed or removed.
launcher.sh list: Displays a list of all programs in the launcher database.
launcher.sh: Launches the dmenu and allows the user to select a program to run.

The launcher is designed to be used with the i3 window manager. To bind the launcher to a keyboard shortcut in i3, add the following line to the i3 config file:

    

bindsym $mod+x exec --no-startup-id /path/to/launcher.sh

The Bash Script

Below is the Bash script that powers the launcher. It uses a Python script to interact with the SQLite database. Enjoy

    

#!/bin/sh

WORKINGDIR="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
pythonScript="${WORKINGDIR}/database.py"

clean_up(){
    while read -r file ; do
        if ! [ -f "$file" ] ; then
            echo "removed: $file"
            python "$pythonScript" del "$file"
        fi
    done <<< "$( python "$pythonScript" get | jq -r '.[]|.location' )"
}

update(){
    tmpfile="/tmp/mydmenu_update_file.csv"
    rm "$tmpfile" 2>/dev/null
    while IFS= read -r -u 3 -d ':'  dir ; do
        #echo "===================================== $dir"
        find "$dir" -type f -iname "*.desktop" -exec grep -L 'NoDisplay=true' {} \; 2>/dev/null |
        while read -r file ; do
            location="$file"
            tname="$(sed -n '/^[nN]ame=/p' "$file" | sed 's/^[nN]ame=//' | tr '\n' ' ' | sed 's/[ \t]*$//' )"
            name=$(echo "$tname" | cut -d' ' -f1,2)
            #echo $file === $name
            exec="$(sed -n '/^[eE]xec=/{s/^[eE]xec=//;s/ %.*//;p;q}' "$file" | tr '\n' ' '  | sed 's/[ \t]*$//' )"
            [[ -z "$exec" ]] && continue
            description="$(sed -n '/^[cC]ategories=/p' "$file" | sed 's/^[cC]ategories=//'  | tr '\n' ' '  | sed 's/[ \t]*$//' )"
            echo "$name,$exec,$location,$description $tname" >> "$tmpfile"
        done
    done 3<<< "$HOME/.local/share/applications:/usr/share/applications:/usr/local/share/applications:"
    python "$pythonScript" update
}

if [ "$1" = "update" ] ; then
    update
    clean_up
    exit
fi

if [ "$1" = "list" ] ; then
    python $WORKINGDIR/database.py get | jq -r '.[]|select(.name)' | less
    exit
fi


data=$(python "$pythonScript" get)
selected=$( echo "$data" | jq -r '.[]|.name' | dmenu -i -fn monospace:20 -p run )
[[ -n "$selected" ]] || exit
program=$(echo "$data" | jq -r ".[]|select(.name|match(\"$selected\"))|.exec" )
python "$pythonScript" increment "$selected"
#echo "$selected"
#echo "$program"
echo "$program" | ${SHELL:-"/bin/sh"} &

Python Script

    

import sqlite3
import json
import csv
import sys
import os
import inspect

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

def connectDB():
    try:
        path = os.path.dirname(os.path.realpath(__file__)) + "/database.db"
        con = sqlite3.connect(path)
        return con
    except sqlite3.Error as error:
        eprint("@%s: %s" % (inspect.stack()[0][3], error))


def createDB():
    con = connectDB()
    cursor = con.cursor()
    cursor.execute( """
        CREATE TABLE IF NOT EXISTS "programs" (
                "name"  TEXT NOT NULL,
                "exec"  TEXT UNIQUE,
                "location"  TEXT,
                "description"   TEXT,
                "uses"  INTEGER DEFAULT 0
        ); """
    )
    con.commit()
    cursor.close()
    con.close()

def update():
    try:
        con = connectDB()
        cursor = con.cursor()
        with open("/tmp/mydmenu_update_file.csv") as ifile:
            reader = csv.reader(ifile,delimiter = ',')
            for f in reader:
                cursor.execute( """ INSERT INTO programs
                 (name,exec,location,description) VALUES (?, ?, ?, ? )
                 ON CONFLICT(location) DO UPDATE SET
                 name= ? , exec= ? , location= ? , description= ?
                 """ , (f[0],f[1],f[2],f[3],f[0],f[1],f[2],f[3]) )
        con.commit()
        cursor.close()
    except sqlite3.Error as error:
        eprint("@%s: %s" % (inspect.stack()[0][3], error))
        print(error)
    finally:
        if con:
            con.close()


def clean_up(p):
    try:
        con = connectDB()
        cursor = con.cursor()
        str_query = """ DELETE FROM programs WHERE location = ? """
        cursor.execute(str_query, (p,) )
        con.commit()
        cursor.close()
    except sqlite3.Error as error:
        eprint("@%s: %s" % (inspect.stack()[0][3], error))
    finally:
        if con:
            con.close()


def increment(p):
    try:
        con = connectDB()
        cursor = con.cursor()
        str_query = """ UPDATE programs SET uses = uses + 1 WHERE name = ? """
        cursor.execute(str_query, (p,) )
        con.commit()
        cursor.close()
    except sqlite3.Error as error:
        eprint("@%s: %s" % (inspect.stack()[0][3], error))
    finally:
        if con:
            con.close()


def get():
    try:
        con = connectDB()
        con.row_factory = sqlite3.Row
        cursor = con.cursor()
        str_query = """ SELECT * from programs ORDER BY uses DESC """
        cursor.execute(str_query)
        rows = cursor.fetchall()
        cursor.close()
        print(json.dumps( [ dict(x) for x in rows] ))
    except sqlite3.Error as error:
        eprint("@%s: %s" % (inspect.stack()[0][3], error))
    finally:
        if con:
            con.close()


def myfuncSwitch(arg):
    cmd = arg[1]
    switcher = {
        "update": update,
        "get": get,
        "del": clean_up,
        "increment": increment,
    }
    func = switcher.get(cmd)
    func(*arg[2:])


if __name__ == "__main__":
    createDB()
    myfuncSwitch(sys.argv)

If you would like to contribute to this personalized dmenu launcher, you can find the Github repository at my github repository. The repository contains the source code for this launcher, and you can use it to make any changes or improvements that you see fit. Additionally, you can submit bug reports or feature requests in the Github issues section. Contributions are always welcome and appreciated, and they can help make this launcher even better. Thank you for your interest in this project, and I look forward to seeing your contributions.

I hope you found this article on my personalized dmenu launcher informative and useful. If you have any ideas or insights that you would like to share, or if you would like to share your experience with this launcher, please feel free to leave a comment below. Your feedback is valuable, and it can help improve this launcher and make it more useful for everyone. Additionally, if you have any questions or concerns, please do not hesitate to ask in the comments section.

ffmpeg command: basic and advanced usage and script examples

2023-02-15T21:04:15+00:00

Introduction to ffmpeg

ffmpeg is a powerful command-line tool for converting, editing, and processing audio and video files. It is available for Linux, as well as other operating systems, and supports a wide range of formats and codecs. As always in this article I will share with you a personal script of mine using ffmpeg

Installing ffmpeg on Linux

Installing ffmpeg on Linux is straightforward. On Debian based distros, you can use the following command:

    

sudo apt install ffmpeg

On Arch linux:

    

sudo pacman -S ffmpeg

Other Linux distributions may have different installation methods. You can check the documentation for your distribution to find the appropriate commands.

Basic Usage of ffmpeg

The basic syntax for using ffmpeg is as follows:

    

ffmpeg [input options] -i input_file [output options] output_file

For example, to convert a video file from one format to another, you can use the following command:

    

ffmpeg -i input.mp4 output.avi

This will convert the input file, `input.mp4`, to the output file, `output.avi`, using the default settings for the output format. You can also specify options such as the bitrate, resolution, and quality of the output file.

Advanced Usage of ffmpeg

ffmpeg can be used for more complex tasks, such as video and audio filtering, cropping and scaling, and adding subtitles or watermarks to a video. You can find more information and examples in the ffmpeg documentation and online tutorials.

Using ffmpeg for Live Streaming and Recording

ffmpeg can also be used for live streaming and recording. It supports a variety of streaming protocols, such as RTMP and HLS, and can encode and stream video and audio in real time.

To start a live stream, you can use a command like the following:

    

ffmpeg -f v4l2 -i /dev/video0 -f alsa -i hw:0 -vcodec libx264 -preset ultrafast -acodec aac -f flv rtmp://streaming_server/live/stream_key

This command uses the video and audio input devices, encodes the video using the `libx264` codec and the audio using the `aac` codec, and streams the output to an RTMP server.

My personal ffmpeg scripts

ffmpeg is really versatile, one cannot really say they know all about it. the following bash script is my go to whenever I need some quick conversion, screen recording or other things. it offers the following functions

    

    $ ff_functions
      0  ff_recscreen
      1  ff_mergeVideoAudio
      2  ff_convertToYoutube
      3  ff_muteVideo
      4  ff_convertToWhatsApp
      5  ff_concatSubscribe

to use it just run it like this, to mute a video for example

    

    $ ff_functions 3 video_file.mp4

    

#!/bin/bash

#screen recording
# $1 can be 2, indication recording the second monitor as per my settings
function ff_recscreen(){
    outputfile="${HOME}/Videos/$(date +%G_%m_%d_at_%H-%M-%S).mkv"
    audioInputSource=$(
    pactl list sources short \
        | awk '{print $2}'\
        | grep input \
        | tail -1
    )
    audioOutputSource=$(
    pactl list sources short \
        | awk '{print $2}' \
        | grep output \
        | tail -1
    )
    SCREEN_res=$(xrandr -q --current | grep '*' | awk '{print $1}' | head -1 )

    if [[ "$1" == "2" ]]
        then  screen="1920+0"
        else  screen="0+0"
    fi
    printf '\033[1;32m audio1 : \033[1;0m %s\n' "$audioInputSource"
    printf '\033[1;32m audio2 : \033[1;0m %s\n' "$audioOutputSource"
    printf '\033[1;32m screen : \033[1;0m %s\n' "$SCREEN_res +0.0+$screen"

    IFS= read -rN 1 -p "continue (Y/n) ? : " answer
    echo
    [[ "$answer" == "n" ]] && return

    ffmpeg \
        -f pulse  -ac 2 -i $audioInputSource \
        -f pulse  -ac 2 -i $audioOutputSource \
        -f x11grab -r 30 -s $SCREEN_res -i :0.0+$screen \
        -af "highpass=f=200, lowpass=f=3000" \
        -acodec pcm_s16le \
        -vcodec libx264 \
        -crf 0 \
        -threads 0 \
        $outputfile
}

# merge video and audio
# $1 : video file
# $2 : audio file
function ff_mergeVideoAudio(){
    video="$1"
    audio="$2"
    ffmpeg \
        -i "$video" \
        -i "$audio" \
        -filter_complex \
        "[0:a]apad[main];[1:a]volume=1.2,apad[A];[main][A]amerge[out]" \
        -c:v copy -c:a aac -map 0:v -map "[out]" \
        -preset ultrafast -threads 0 \
        -ac 2 -pix_fmt yuv420p  \
        -shortest \
        "${video%.*}-${audio%.*}_mixed.mp4"
}

# convert large video file to a reasonable size, no loss of quality
# $1 : video file
function ff_convertToYoutube(){
    video="$1"
    ffmpeg \
        -i "$video" \
        -c:v libx264 \
        -crf 24 \
        -b:v 1M \
        "${video%.*}_converted.mp4"
}

# remove audio from video file
# $1 : video file
function ff_muteVideo(){
    video="$1"
    ffmpeg \
        -i "$video" \
        -c:v copy \
        -an \
        "${video%.*}_muted.mp4"
}

# reduce video size to make it uploadable to whatsapp
# $1 : video file
function ff_convertToWhatsApp(){
    video="$1"
    ffmpeg \
        -i "$video" \
        -c:v libx264 \
        -profile:v baseline \
        -level 3.0 \
        -pix_fmt yuv420p \
        "${video%.*}_whatsapp.mp4"
}

# add add an image to the end of a video
function ff_concatSubscribe(){
    video="$1"
    image="$2"

    #get the video duration:

    dd=$(ffmpeg -i "$1" 2> &1 | grep Duration | awk '{print $2}' | tr -d , )
    m=$(echo "$dd" | cut -d: -f2 )
    s=$(echo "$dd" | cut -d: -f3 | cut -d. -f1)
    duration=$((m*60+s+2))

    #create a slightly longer video from the image:

    ffmpeg \
        -loop 1 \
        -i "$image" \
        -f lavfi -i anullsrc \
        -c:v libx264 \
        -c:a aac \
        -t $duration \
        -pix_fmt yuv420p \
        -vf scale=1902:1080 \
        -b:v 1M \
        -y "${image%.*}.mp4"

    #concat video and image:

    ffmpeg \
        -i "$video" \
        -i "${image%.*}.mp4" \
        -filter_complex "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]" \
        -map "[v]" -map "[a]" \
        -shortest \
        -y output.mkv
    exit
}

readarray -t y <<< "$( cat "$0"  |grep ^function |sed 's/function//g;s/[(){]//g' )"

if [[ -z "$1" ]]
    then
        for (( k=0;k<${#y[$@]}; k++ )) ; do
            ! [[ -z "${y[$k]}" ]] && printf "$k\t${y[$k]}\n"
        done
    else
        ${y[$1]} "$2" "$3" "$4"
fi

Conclusion and Further Resources

ffmpeg is a versatile and powerful tool for audio and video processing in Linux. With the right options and techniques, you can use it to perform a wide range of tasks, from simple conversions to complex video processing and live streaming. For more information, you can consult the ffmpeg documentation and online forums and communities.

i3 Window Manager: supporting scripts part 1

2023-02-15T16:21:08+00:00

This article is a continuation to the previous article about i3 window manager where I shared my config file. which contained many of my bash scripts. in this first article I will share 3 scripts. one checks weither a workspace is empty. the second one helps me in moving windows to other workspaces and the last one is for listing the available keyboard combinations

workspace is empty

this script uses two commands/tools xprop and xdotool to check weither the workspace/desktop is empty or not. I used it with some of my conky scripts to only show conky window if there is no other window in the workspace. it should return 1 if no windows are visible, and 0 otherwise

    

#!/bin/bash

# get the zero based index of current workspace
DESKTOP=$(xprop -notype -root _NET_CURRENT_DESKTOP | cut -c 24-)

# get the list of ID's of the windows in the current workspace/desktop
WINDOWS=$(xdotool search --all --onlyvisible --desktop $DESKTOP "" 2>/dev/null)

# count them
number_windows=$(echo "$WINDOWS" | wc -c)

if (( $number_windows > 1 ))
    then echo 0
    else echo 1
fi

Go to workspace, move window to workspace

In this script I use a small Dialog window generated by the program zenity that takes a number and go to that workspace

    

#!/bin/bash

# we set the dialog title

title="Go to"
[[ "$1" == "move" ]] && title="Move window To"

#we get the number from the dialog window

ws=$(
    zenity --entry --text="workspace:" --title="$title"
)

# we only accept numbers as input

number='^[0-9]+$'
if ! [[ "$ws" =~ $number ]]
    then exit
fi

# the script takes an argument "move". if so then we move the highlighted
# window to workspace $ws. otherwise we go to workspace $ws
# using the i3 built-in command i3-msg

if [[ "$1" == "move" ]]
    then
        i3-msg "move container to workspace $ws"
    else
        i3-msg "workspace $ws"
fi

Free keys

In this script I loop through the alphabet from {a..z} and each time check for the existence of keyboard combinations such as "ALT+a" "WIN+a" "CONTROL+ALT+a" if grep does not find it then it is free

    

#!/bin/bash
echo "========================"
for a in `echo {a..z}` ; do
    if ! grep -w " mod1+$a" ~/.i3/config >/dev/null ; then
        echo "ALT+$a is free"
    fi
done
echo "========================"
for a in `echo {a..z}` ; do
    if ! grep -w "\$mod+$a" ~/.i3/config >/dev/null ; then
        echo "WIN+$a is free"
    fi
done
echo "========================"
for a in `echo {a..z}` ; do
    if ! grep -w "\$mod+mod1+$a" ~/.i3/config >/dev/null ; then
        if ! grep -w "mod1+\$mod+$a" ~/.i3/config >/dev/null ; then
            echo "WIN+ALT+$a is free"
        fi
    fi
done

i3 Window Manager: Introduction and My Personal config

2023-02-14T22:43:58+00:00

i3 is a tiling window manager designed for Unix-like operating systems. It is lightweight, fast, and highly configurable, making it a popular choice among power users and developers.

Unlike traditional window managers that use a desktop metaphor, i3 divides your screen into a grid of tiles and arranges your windows in a non-overlapping way. This allows you to maximize your screen real estate and be more productive.

Some of the key features of i3 include:

Tiling layout
Keyboard-driven
Multiple workspaces
Customizable keybindings
Support for floating windows

If you're new to i3, here are some basic commands to get you started:

mod+enter: open a new terminal window
mod+d: open the dmenu (a launcher for applications)
mod+shift+q: close the current window
mod+1-9: switch to workspace 1-9
mod+shift+1-9: move the current window to workspace 1-9

To customize i3, you'll need to edit the configuration file located at ~/.config/i3/config. This file is written in a simple syntax and allows you to change keybindings, set up custom commands, and configure your i3 setup to your liking.

Overall, i3 is a powerful and highly customizable window manager that can help you be more productive and efficient in your daily work. If you're looking for a lightweight and fast alternative to traditional desktop environments, give i3 a try!

My i3 config file updated over the years

Ever since I installed Arch Linux with i3 window manager. I instantly fallen in love with it and I've never gone back to other systems. it is great. and once you get into the art of creating your own scripts for your needs you will never part ways with i3wm.

Dear visitor Please bear in mind that there are a lot of script files there that are for my personal system, once you copy the config file you have to change some things accordingly. feel free to ask about those files in the comments section bellow and I'll make sure to post them and notify you via Email

    


set $mod Mod4
set $altgr mod5

#i3-gaps
#gaps inner 12

font pango:monospace 12

# Use Mouse+$mod to drag floating windows to their wanted position
floating_modifier $mod

# start a terminal
#bindsym    $mod+Return         exec --no-startup-id i3-sensible-terminal
bindsym     $mod+t          exec --no-startup-id lxterminal
bindsym     $mod+Return         exec --no-startup-id lxterminal
bindsym     $mod+KP_Enter       exec --no-startup-id terminator
bindsym     mod1+s              exec --no-startup-id terminator




# kill focused window
 bindsym     mod1+x             kill
 bindsym     button3            floating toggle

# start program launchers
bindsym     $mod+shift+x    exec --no-startup-id "rofi -show combi "
bindsym     $mod+c      exec --no-startup-id ~/.i3/dm-mylocate.sh
bindsym     $mod+s      exec --no-startup-id ~/.i3/s-surf.sh
bindsym     $mod+g      exec --no-startup-id ~/.i3/dm-menu.sh '2 - search'
bindsym     mod1+a      exec --no-startup-id ~/.i3/apropos-man.sh aaa
bindsym     $mod+x      exec --no-startup-id ~/bin/mylauncher/launcher.sh
#bindsym     $mod+x     exec --no-startup-id "i3-dmenu-desktop --dmenu='dmenu -i -fn monospace:20 -p run'"

# change focus
#bindsym $mod+j focus left
#bindsym $mod+k focus down
#bindsym $mod+l focus up
#bindsym $mod+m focus right

# alternatively, you can use the cursor keys:
 bindsym $mod+Left          focus left
 bindsym $mod+Down          focus down
 bindsym $mod+Up            focus up
 bindsym $mod+Right         focus right

# # move focused window
# bindsym $mod+Shift+j       move left
# bindsym $mod+Shift+k       move down
# bindsym $mod+Shift+l       move up
# bindsym $mod+Shift+M       move right

 # alternatively, you can use the cursor keys:
 bindsym $mod+Shift+Left    move left
 bindsym $mod+Shift+Down    move down
 bindsym $mod+Shift+Up      move up
 bindsym $mod+Shift+Right   move right

 # split in horizontal orientation
 bindsym $mod+h split h

 # split in vertical orientation
 bindsym $mod+v split v

 # enter fullscreen mode for the focused container
 bindsym $mod+f fullscreen toggle

 # Make the currently focused window a scratchpad
 bindsym $mod+q move scratchpad
 # Show the first scratchpad window
 bindsym $mod+Shift+s scratchpad show
 # change container layout (stacked, tabbed, toggle split)
 bindsym $mod+a layout stacking
 bindsym $mod+z layout tabbed
 bindsym $mod+e layout toggle split

 # toggle tiling / floating
 bindsym $mod+Shift+space floating toggle

 # change focus between tiling / floating windows
 bindsym $mod+space focus mode_toggle

 # focus the parent container
 #bindsym $mod+q focus parent

 # focus the child container
 #bindsym $mod+d focus child

 # Define names for default workspaces for which we configure key bindings later on.
# We use variables to avoid repeating the names in multiple places.
set $ws1           "1: root"
set $ws2           "2: net"
set $ws3           "3: Media"
set $ws4           "4: Files"
set $ws5           "5: Work"
set $ws6           "6: Docs"
set $ws7           "7"
set $ws8           "8"
set $ws9           "9"
set $ws10          "10"
set $ws11          "11"
set $ws12          "12"
set $ws13          "13"

# switch to workspace
 bindsym $mod+ampersand              workspace $ws1
 bindsym $mod+eacute                 workspace $ws2
 bindsym $mod+quotedbl               workspace $ws3
 bindsym $mod+apostrophe             workspace $ws4
 bindsym $mod+parenleft          workspace $ws5
 bindsym $mod+minus                  workspace $ws6
 bindsym $mod+egrave                 workspace $ws7
 bindsym $mod+underscore             workspace $ws8
 bindsym $mod+ccedilla               workspace $ws9
 bindsym $mod+agrave                 workspace $ws10
 bindsym $mod+parenright             workspace $ws11
 bindsym $mod+equal              workspace $ws12
 bindsym $mod+control+twosuperior    workspace $ws13

# switch to workspace
 bindsym $mod+control+ampersand              workspace "14"
 bindsym $mod+control+eacute                 workspace "15"
 bindsym $mod+control+quotedbl               workspace "16"
 bindsym $mod+control+apostrophe             workspace "17"
 bindsym $mod+control+parenleft          workspace "18"
 bindsym $mod+control+minus                  workspace "19"
 bindsym $mod+control+egrave                 workspace "20"
 bindsym $mod+control+underscore             workspace "21"
 bindsym $mod+control+ccedilla               workspace "22"
 bindsym $mod+control+agrave                 workspace "23"
 bindsym $mod+control+parenright             workspace "24"
 bindsym $mod+control+equal                  workspace "25"

 # move focused container to workspace
 bindsym $mod+Shift+ampersand       move container to workspace $ws1
 bindsym $mod+Shift+eacute          move container to workspace $ws2
 bindsym $mod+Shift+quotedbl        move container to workspace $ws3
 bindsym $mod+Shift+apostrophe      move container to workspace $ws4
 bindsym $mod+Shift+parenleft       move container to workspace $ws5
 bindsym $mod+Shift+minus       move container to workspace $ws6
 bindsym $mod+Shift+egrave          move container to workspace $ws7
 bindsym $mod+Shift+underscore      move container to workspace $ws8
 bindsym $mod+Shift+ccedilla        move container to workspace $ws9
 bindsym $mod+Shift+agrave          move container to workspace $ws10
 bindsym $mod+Shift+parenright      move container to workspace $ws11
 bindsym $mod+Shift+equal           move container to workspace $ws12
 bindsym $mod+Shift+twosuperior     move container to workspace $ws13

 # move focused container to workspace
 bindsym $mod+control+Shift+ampersand       move container to workspace  "14"
 bindsym $mod+control+Shift+eacute          move container to workspace  "15"
 bindsym $mod+control+Shift+quotedbl        move container to workspace  "16"
 bindsym $mod+control+Shift+apostrophe      move container to workspace  "17"
 bindsym $mod+control+Shift+parenleft       move container to workspace  "18"
 bindsym $mod+control+Shift+minus       move container to workspace  "19"
 bindsym $mod+control+Shift+egrave          move container to workspace  "20"
 bindsym $mod+control+Shift+underscore      move container to workspace  "21"
 bindsym $mod+control+Shift+ccedilla        move container to workspace  "22"
 bindsym $mod+control+Shift+agrave          move container to workspace  "23"
 bindsym $mod+control+Shift+parenright      move container to workspace  "24"
 bindsym $mod+control+Shift+equal           move container to workspace  "25"

bindsym $mod+w      exec --no-startup-id   ~/.i3/move_to_ws.sh
bindsym $mod+shift+w    exec --no-startup-id   ~/.i3/move_to_ws.sh move

 # dual monitor settings
 #exec_always --no-startup-id xrandr --output HDMI-1 --right-of eDP-1
 set $firstmonitor eDP1
 set $secondmonitor HDMI1

 workspace $ws1 output  $firstmonitor
 workspace $ws2 output  $firstmonitor
 workspace $ws4 output  $firstmonitor
 workspace $ws8 output  $firstmonitor
 workspace $ws9 output  $secondmonitor
 workspace $ws3 output  $secondmonitor
 workspace $ws5 output  $secondmonitor
 workspace $ws7 output  $secondmonitor

assign [class="Transmission-gtk"] $ws3
assign [class="Navigator|firefox"] $ws2
assign [class="libreoffice-calc|libreoffice-writer"] $ws5
assign [class="Chromium|Google-chrome"] $ws11
assign [class="Tor Browser"] $ws7
assign [class="VirtualBox Manager"] $ws7
assign [class="sqlitebrowser|DB Browser for SQLite"] $ws6
assign [class="Evince|Org.gnome.gedit|MuPDF"] $ws6
assign [class="VirtualBox Machine"] $ws6
assign [class="obs|explorer.exe|Wine|huniepop.exe|joey_pc.exe"] $ws12
assign [class="openshot|QtCreator|TeXstudio|code-oss|Atom"] $ws11
#
#
#some window parameters
for_window [class="mpv|Tor Browser|Transmission-gtk|vlc|Pavucontrol"] floating enable border normal
for_window [class="Gnome-system-monitor|smplayer|Gnome-calculator"] floating enable border normal
for_window [class="Pidgin|Woeusbgui|Wicd-client.py"] floating enable border normal
for_window [class="VirtualBox Manager|florence|Florence"] floating enable border normal
for_window [class="TelegramDesktop|Qalculate-gtk"] floating enable border normal
for_window [class="feh|fim"] floating enable move absolute position 0px 0px
#for_window [class="Lxterminal|lxterminal"] resize set 1200 700
for_window [class="Xfce4-terminal|Surf"] floating enable border normal
for_window [class="Xfce4-terminal"] resize set 1600 700
for_window [class="Surf"] resize set 1200 650
for_window [class="Xfce4-terminal|Surf"] move absolute position 70 70
for_window [class="Google-chrome|firefox|Chromium"] resize set width 33 ppt
#for_window [class="VirtualBox Machine"] floating enable, resize set 1601 900, move position 0 0
#

#new_window normal
#set $background  #e0eaf9
#
## class                 border  backgr. text    indicator child_border
#client.focused          #271f17 #271f17 #AAAAAA #AAAAAA   #C93F2C
#client.focused_inactive #21211d #1d2121 #a1a1a1 #484e50   #1d2121
#client.unfocused        #333333 #222222 #888888 #292d2e   #222222
#client.urgent           #4a4b4c #4a4b4c #AAAAAA #AAAAAA   #4a4c4b
#client.placeholder      #000000 #0c0c0c #AAAAAA #000000   #0c0c0c
#
#client.background       #111111

# reload the configuration file
# bindsym $mod+Shift+c reload
# restart i3 inplace (preserves your layout/session, can be used to upgrade i3)
 bindsym $mod+Shift+r restart
# exit i3 (logs you out of your X session)
 bindsym $mod+Shift+e   exec --no-startup-id "i3-nagbar -t warning -m 'You pressed the exit shortcut. Do you really want to exit i3? This will end your X session.' -b 'Yes, exit i3' 'i3-msg exit'"
 bindsym $mod+control+Escape exec --no-startup-id 'i3-msg exit'

# resize window (you can also use the mouse for that)
mode "resize" {
# These bindings trigger as soon as you enter the resize mode

# Pressing left will shrink the window’s width.
# Pressing right will grow the window’s width.
# Pressing up will shrink the window’s height.
# Pressing down will grow the window’s height.
        bindsym j resize shrink width 10 px or 10 ppt
        bindsym k resize grow height 10 px or 10 ppt
        bindsym l resize shrink height 10 px or 10 ppt
        bindsym m resize grow width 10 px or 10 ppt

# same bindings, but for the arrow keys
        bindsym Left  resize shrink width   10 px or 10 ppt
        bindsym Down  resize shrink height  10 px or 10 ppt
        bindsym Up    resize grow   height  10 px or 10 ppt
        bindsym Right resize grow   width   10 px or 10 ppt

# back to normal: Enter or Escape or $mod+r
        bindsym Return mode "default"
        bindsym Escape mode "default"
        bindsym $mod+r mode "default"
}

 bindsym $mod+r mode "resize"


# Start i3bar to display a workspace bar (plus the system information i3status
# finds out, if available)

#Polybar to replace the default i3statusbar:
#exec_always --no-startup-id $HOME/.config/polybar/launch.sh boot

bar {
    colors {
        background #000000
        # statusline #00A5FF #that neon blue
        separator #000000
        focused_workspace  #4c7899 #285577 #ffffff
        active_workspace   #333333 #5f676a #ffffff
        inactive_workspace #333333 #222222 #888888
        urgent_workspace   #2f343a #900000 #ffffff
    }
    font pango:FontAwesome Bold 9
#tray_output none
    status_command i3blocks -c ~/.i3/top-bar/i3blocks.conf
    position    top
#bindsym --release button3  exec --no-startup-id scrot '%Y-%m-%d-%s_$wx$h.png' -e 'mv $f ~/Pictures/' && mplayer ~/.i3/Nikon.ogg
}

#bar {
#    font pango:FontAwesome Bold 20
#    status_command i3blocks -c ~/.i3/bottom-bar/i3blocks.conf
#    position   bottom
#    modifier    Mod4
#    mode        hide
#    hidden_state hide
#    workspace_buttons no
#}

# Pulse Audio controls
 bindsym XF86AudioRaiseVolume       exec --no-startup-id /home/mosaid/bin/vv + 2
 bindsym XF86AudioLowerVolume       exec --no-startup-id /home/mosaid/bin/vv - 2
 bindsym XF86AudioMute          exec --no-startup-id /home/mosaid/bin/vv mute

 # Screen brightness controls
 #bindsym XF86MonBrightnessUp       exec --no-startup-id xbacklight -inc 20 # increase screen brightness
 #bindsym XF86MonBrightnessDown     exec --no-startup-id xbacklight -dec 20 # decrease screen brightness
 bindsym XF86MonBrightnessUp        exec --no-startup-id light -A 10 # increase screen brightness
 bindsym XF86MonBrightnessDown      exec --no-startup-id light -U 10 # decrease screen brightness

# Touchpad controls
#bindsym XF86TouchpadToggle     exec --no-startup-id /some/path/toggletouchpad.sh # toggle touchpad
#bindsym XF86TouchpadToggle     exec --no-startup-id vlc

# Media player controls
 bindsym XF86AudioPlay              exec --no-startup-id /home/mosaid/bin/mympc.sh pp
 bindsym XF86AudioPause         exec --no-startup-id /home/mosaid/bin/mympc.sh pp
 bindsym XF86AudioNext              exec --no-startup-id /home/mosaid/bin/mympc.sh
 bindsym XF86AudioPrev              exec --no-startup-id /home/mosaid/bin/mympc.sh p

 #screenshots
bindsym Print                   exec --no-startup-id  ~/.i3/screenshot.sh 1
bindsym mod1+control+p              exec --no-startup-id  ~/.i3/screenshot.sh 1
bindsym mod1+control+o              exec --no-startup-id  ~/.i3/screenshot.sh 2

#other keyboard shortcuts
bindsym $mod+l                      exec --no-startup-id  betterlockscreen --lock
bindsym $mod+n                      exec --no-startup-id  ~/bin/playFromClipboard.sh npr
bindsym $mod+m                  exec --no-startup-id  ~/.i3/top-bar/user.sh menu
bindsym mod1+space              exec --no-startup-id  ~/bin/mpd-controls.sh pp
bindsym control+mod1+space          exec --no-startup-id  ~/bin/mpd-controls.sh m
bindsym mod1+n                      exec --no-startup-id  ~/bin/mpd-controls.sh n
bindsym mod1+b                      exec --no-startup-id  ~/bin/mpd-controls.sh p
bindsym mod1+v                      exec --no-startup-id  ~/bin/mpd-controls.sh v
bindsym mod1+c                      exec --no-startup-id  ~/bin/mpd-controls.sh vv
bindsym mod1+r                      exec --no-startup-id  ~/bin/mpd-controls.sh r
bindsym mod1+w                      exec --no-startup-id  ~/.i3/pplay/play.sh
#bindsym mod1+f                     exec --no-startup-id  ~/bin/conkyfont.sh
bindsym $mod+mod1+g             exec --no-startup-id  ~/.i3/shortcuts-conky.sh
bindsym mod1+d                      exec --no-startup-id  ~/bin/myBash_functions.sh eglllr
bindsym mod1+t                      exec --no-startup-id  ~/bin/myBash_functions.sh ttor
bindsym control+less                exec --no-startup-id  ~/bin/ws.sh ++
bindsym control+shift+less          exec --no-startup-id  ~/bin/ws.sh --

#startup
#exec           --no-startup-id wicd-gtk -t
#exec           --no-startup-id firefox
#exec           --no-startup-id pidgin
#exec            --no-startup-id transmission-gtk -m
#exec           --no-startup-id udiskie
#exec           --no-startup-id ~/.i3/start-conky.sh
#exec           --no-startup-id ~/.i3/prayerTime.sh
#exec           --no-startup-id ~/.i3/pplay/pplayEngine.sh
exec            --no-startup-id ~/.i3/onedriveMonitor.sh
#exec           --no-startup-id ~/.i3/touchpadSettings.sh
exec            --no-startup-id redshift
exec_always     --no-startup-id numlockx on
exec_always     --no-startup-id picom --config ~/.i3/picom.conf
exec_always     --no-startup-id xkb-switch --i3

set $mode_display Mirrored (c) , Ext Screen (v) , HDMI ON (b) , HDMI OFF (n)
mode "$mode_display" {
    bindsym c   exec  --no-startup-id ~/.i3/display.sh mirrored , mode "default"
    bindsym v   exec  --no-startup-id ~/.i3/display.sh extended , mode "default"
    bindsym b   exec  --no-startup-id ~/.i3/display.sh mirrored , mode "default"
    bindsym n   exec  --no-startup-id ~/.i3/display.sh default  , mode "default"

    bindsym Return mode "default"
    bindsym Escape mode "default"
}
#
 bindsym $mod+d mode "$mode_display"
#bindsym $mod+d             exec --no-startup-id ~/.i3/display.sh
#bindsym XF86Display    exec --no-startup-id ~/.i3/display.sh

# multitouch gestures
 bindsym --whole-window $mod+button10 workspace prev_on_output
 bindsym --whole-window $mod+button11 workspace next_on_output

#keyboard layout
exec_always --no-startup-id "setxkbmap -model pc104 -layout fr,ar -variant ,, -option grp:alt_shift_toggle"
#bindsym --release Caps_Lock exec --no-startup-id pkill -SIGRTMIN+11 i3blocks
#bindsym --release Num_Lock  exec --no-startup-id pkill -SIGRTMIN+11 i3blocks

#switch to greeter and login
#bindsym $mod+twosuperior exec dm-tool switch-to-greeter


set $playFromClipboard play From ClipBoard (c), play next youtube video (v)
mode "$playFromClipboard" {

    bindsym c  exec --no-startup-id ~/bin/playFromClipboard.sh
    bindsym v  exec --no-startup-id ~/bin/playFromClipboard.sh n

    bindsym Escape mode "default"
}

 bindsym mod1+p mode "$playFromClipboard"

set $mode_system System (l) lock, (e) logout, (s) suspend, (h) hibernate, (r) reboot, (Shift+s) shutdown
mode "$mode_system" {
    bindsym l exec --no-startup-id i3exit.sh lock, mode "default"
    bindsym e exec --no-startup-id i3exit.sh logout, mode "default"
    bindsym s exec --no-startup-id i3exit.sh suspend, mode "default"
    bindsym h exec --no-startup-id i3exit.sh hibernate, mode "default"
    bindsym r exec --no-startup-id i3exit.sh reboot, mode "default"
    bindsym Shift+s exec --no-startup-id i3exit.sh shutdown, mode "default"

    # back to normal: Enter or Escape
    bindsym Return mode "default"
    bindsym Escape mode "default"
}
 bindsym $mod+Shift+q mode "$mode_system"

ed text editor: An advanced tutorial with scripts

2023-02-13T14:05:12+00:00

ed is a line-oriented text editor that was popular in the early days of Unix. Although it's not as widely used today as more modern text editors like vi or emacs, it's still available on many systems and is sometimes used for scripting purposes.

Starting ed

To start the ed editor, simply type "ed" at the command prompt and press Enter. You will be taken to the ed prompt, which looks like this:

    

  $ ed

To open an existing file in ed, you can use the following syntax:

    

  $ ed <file name>

Basic commands

The ed editor is controlled by typing commands at the prompt. Some basic commands include:

a: append text to the end of the file
i: insert text before the current line
p: print the current line
d: delete the current line
q: quit the editor

Advanced commands

In addition to the basic commands, ed also supports a number of more advanced commands for editing text:

c: change the current line
n: print the current line number
/text/: search for the specified text
s/old/new/: replace the first occurrence of "old" with "new" in the current line
s/old/new/g: replace all occurrences of "old" with "new" in the current line
u: undo the last change

Adding text

To add text to the file, use the 'a' command. After you type 'a', you can enter the text you want to add. To end the text input and return to the ed prompt, press the escape key (ESC).

    

  $ ed
  a
  <text to be added>
  ESC

Saving and quitting

To save your changes and quit the editor, type 'w' followed by 'q'. To quit without saving changes, simply type 'q'.

wq

In addition to using ed interactively, it's also possible to use ed to perform one-line commands from the terminal. These commands are useful for quickly editing a file without having to start the interactive editor. For example, to replace text between two patterns in a file, you can use the following syntax:

    

$ echo 'text to be edited' | ed -s file.txt <<< $'/pattern1/,/pattern2/s/old/new/g\nw\nq'

This will replace all occurrences of "old" with "new" in the file "file.txt" between the first line containing "pattern1" and the first line containing "pattern2". The changes will be saved to the file and the ed editor will quit.

    

$ printf '%s\n' "/$pattern1/+1,/$pattern2/-1d" "/$pattern1/a" "$TEXT" . wq | ed -s "$texFile"

This command uses the `printf` command to generate the ed commands, which are passed to the `ed` editor using a pipe. The first line of the generated commands, `"/$pattern1/+1,/$pattern2/-1d"`, deletes all lines from the line after the first occurrence of `$pattern1` to the line before the first occurrence of `$pattern2`. The second line of the commands, `"/$pattern1/a"`, appends the text `$TEXT` to the line containing `$pattern1`. The `.` on the last line of the commands saves the changes and the `wq` quits the editor.

    

# Append text to the end of a file
$ echo "$TEXT" | ed -s "$file" <<< $'$a\n'"$TEXT"'\n.\nw\nq'

# Insert text at the beginning of a file
$ echo "$TEXT" | ed -s "$file" <<< $'0a\n'"$TEXT"'\n.\nw\nq'

# Replace a line in a file
$ echo "$TEXT" | ed -s "$file" <<< $'$LINE_NUMBER c\n'"$TEXT"'\n.\nw\nq'

# Delete a line from a file
$ ed -s "$file" <<< $"$LINE_NUMBER d\n.\nw\nq"

# Search and replace text in a file
$ ed -s "$file" <<< $'1,$s/old/new/g\n.\nw\nq'

# Search for a pattern and print matching lines
$ ed -n "$file" <<< $'/PATTERN/p\nq'

In these examples, `$TEXT` is the text you want to insert, `$LINE_NUMBER` is the line number in the file where you want to perform an operation, `$file` is the name of the file you want to edit, `old` is the text you want to replace, `new` is the replacement text, and `PATTERN` is the pattern you want to search for.

    

#!/bin/sh

# Define the file to edit
file="file.txt"

# Define the text to insert
text="This is some text"

# Define the line number to insert the text at
line_number=3

# Use ed to insert the text at the specified line number
ed -s "$file" <<-EOF
$line_number
a
$text
.
w
q
EOF

This script uses ed to insert the text `$text` at line number `$line_number` in the file `$file`. The script starts by defining the file to edit, the text to insert, and the line number to insert the text at. The script then uses ed in a here document to insert the text. The here document contains ed commands to go to the specified line number, append the text, save the changes, and quit the editor.

let's say we have a log file that contains entries. and it is organized this way:

.....
%%12:01-02-2022:start
    ....
%%12:01-02-2022:end
%%13:17-07-2022:start
    ....
%%13:17-07-2022:end
%%14:21-10-2022:start
    ....
%%14:21-10-2022:end
....

Each entry starts with pattern %%entry_number:entry_date:start and ends with %%entry_number:entry_date:end. suppose we want to edit an entry but we only know its date and number but we don't want to browse the millions of lines manually to find it. with "ed" and other commands like "grep" we can do that.

    

#!/bin/sh

# Define the log file
log_file="log.txt"

# Define the start pattern
start_pattern="%%entry_number:entry_date:start"

# Define the end pattern
end_pattern="%%entry_number:entry_date:end"

# Get the start line number of the entry
start_line_number=$(grep -n "$start_pattern" "$log_file" | awk -F: '{print $1}')

# Get the end line number of the entry
end_line_number=$(grep -n "$end_pattern" "$log_file" | awk -F: '{print $1}')

# Use ed to extract the entry into a temporary file
ed -n "$log_file" <<-EOF
$start_line_number,$end_line_number w entry.tmp
q
EOF

# Edit the temporary file as needed
# ...

# Use ed to reinsert the edited entry into the log file
ed -s "$log_file" <<-EOF
$start_line_number,$end_line_number d
$start_line_number
r entry.tmp
.
w
q
EOF

In this example, the script uses `grep` to search for the start and end patterns in the log file and retrieve the line numbers where they occur. The script then uses the line numbers in the `ed` commands to extract and reinsert the entry in the same way as in the previous example.

ed text editor and many other similar tools take advantage of the organized and repetitive patterns found in many configuration files, making it easier to automate and manipulate these files in various ways. This is because ed and other tools are designed to work with text files, and these repetitive patterns allow these tools to locate specific information and make changes to it with just a few simple commands. Additionally, these tools can be combined with other utilities, such as grep, to further increase their functionality and allow for even more advanced text manipulation. This is why the well-organized structure of configuration files is so important in the world of computing, as it allows for a wide range of powerful and efficient tools to be used to manage and manipulate these files.

Conclusion

In conclusion, ED is a powerful and versatile text editor that offers many features and functionalities for advanced text manipulation. From basic editing tasks to complex text operations, ED provides a simple and efficient way to work with text files in a Unix environment. Whether you are a seasoned developer or just getting started, ED is definitely worth exploring and learning.

An Introduction to Kali Linux

2023-02-05T21:09:30+00:00

An Introduction to Kali Linux

Kali Linux is a Debian-based Linux distribution designed for digital forensics and penetration testing. It is a popular tool for security professionals, ethical hackers, and enthusiasts, who use it to test the security of their own systems and networks, as well as those of their clients. In this article, we'll explore what Kali Linux is, its features, and why it is an essential tool for those in the security industry.

What is Kali Linux?

Kali Linux is a Debian-based Linux distribution that is widely used for penetration testing, digital forensics, and security research. It was created and developed by Offensive Security, a leading provider of security training and services. Kali Linux is built on a strong foundation of open-source software and is continuously updated to include the latest security tools and features.

Features of Kali Linux

One of the key features of Kali Linux is its extensive collection of security tools, which are organized into categories such as information gathering, vulnerability analysis, exploitation tools, password attacks, wireless attacks, and web applications. This makes it easy for users to find the tools they need for their specific task or project.

Kali Linux also includes a custom desktop environment, which provides a user-friendly interface for accessing and using the tools. Additionally, Kali Linux is designed to be lightweight and fast, making it ideal for use on low-end hardware and older computers.

Example Commands for Different Categories

Information Gathering

One of the most popular tools for information gathering in Kali Linux is Nmap, which is used to scan networks and identify open ports and running services. An example command for using Nmap to scan a network is:

nmap 192.168.1.0/24

Vulnerability Analysis

A popular tool for vulnerability analysis in Kali Linux is OpenVAS, which is used to identify vulnerabilities in systems and networks. An example command for using OpenVAS is:

openvas-launch

Exploitation Tools

A widely used exploitation tool in Kali Linux is Metasploit, which is used to exploit vulnerabilities in systems and networks. An example command for using Metasploit is:

msfconsole

Password Attacks

One of the most popular tools for password attacks in Kali Linux is John the Ripper, which is used to crack passwords. An example command for using John the Ripper is:

john --wordlist=/usr/share/wordlists/rockyou.txt hashfile.txt

Conclusion

Kali Linux is a powerful and versatile Linux distribution that is widely used in the security industry. Its extensive collection of security tools, user-friendly interface, and lightweight design make it a popular choice for those who need to test the security of their systems and networks. Whether you are a security professional, ethical hacker, or enthusiast, Kali Linux is a valuable tool to have in your arsenal.

However, it is important to note that Kali Linux should only be used for lawful purposes and with the proper knowledge and training. Using Kali Linux for malicious purposes or without proper understanding of its tools can have serious consequences, both legally and ethically.

In conclusion, Kali Linux is a useful tool for those in the security industry, but it should be used responsibly and with the proper understanding of its capabilities and limitations.

Linux vs Windows: Understanding the Differences

2023-02-05T17:10:27+00:00

When it comes to operating systems, Linux and Windows are two of the most popular choices. While both systems have their own unique features, there are some key differences that set them apart.

Definition of Key Terms

Kernel: The kernel is the central component of an operating system. It acts as the intermediary between software applications and the computer hardware. The kernel controls the allocation of resources, such as CPU time, memory, and disk space, among other things.
File Manager: A file manager is a software application used for organizing and manipulating files on a computer. It provides a graphical user interface for accessing and manipulating files, folders, and disks.
Desktop Environment (DE): A desktop environment is a graphical user interface that runs on top of a computer's operating system. It provides the user with a graphical interface for accessing and managing files, applications, and other resources.

Access to Directories and Processes

In Windows, users have limited control over many directories and processes, as they are protected by the operating system. This means that users do not have the ability to access or modify certain parts of the system.

In Windows, even a software developer has no direct access to the Windows kernel. Access to the kernel is through multiple layers, such as the WinAPI and the WinNTDLL. This means that developers have to work with APIs (Application Programming Interfaces) to communicate with the kernel.

Windows users are not able to change the Windows file manager "Explorer.exe". This is because Explorer.exe is a core component of the Windows operating system and cannot be replaced or altered by users.

The same goes for the Desktop Environment (DE) in Windows. Windows users are not able to change the DE that is built into the operating system.

windows OS architecture: user -> winAPI -> ntDLL -> kernel

On the other hand, in Linux, users have complete control over the system, including all directories and processes. The superuser account, also known as "root", has complete control over the system, including the ability to modify or delete any part of the system.

linux architecture: completely documented, open source and available

In Linux, system calls go directly to the kernel. This gives Linux developers more control over the system and the ability to directly communicate with the kernel. Linux users have the ability to change both their file manager and DE if they so choose.

This level of customization is one of the key differences between Linux and Windows. Linux offers users more flexibility and control over their computing environment, while Windows provides a more standardized and controlled environment.

This level of control can be both an advantage and a disadvantage. On one hand, it allows users to have complete control over their system and the ability to customize it to their needs. On the other hand, it also means that users have the ability to completely wipe out their system if they are not careful.

Conclusion

These are just some of the differences between Linux and Windows. Both systems have their own advantages and disadvantages, and the best choice for you will depend on your needs and preferences.

A Guide to the Linux Operating System

2023-02-04T21:01:25+00:00

Linux is a free, open-source operating system that has become increasingly popular in recent years, both for personal and professional use. It is known for its stability, security, and versatility, and is used by millions of people around the world. This article will provide an overview of the Linux operating system, including the different distributions, desktop environments, package managers, and file managers that are available.

Distributions

One of the most notable features of Linux is the availability of different distributions, or "distros". These are essentially different versions of the operating system that are tailored to meet the specific needs and preferences of users. There are two main types of distros: Debian-based and Arch-based. Debian-based distros, such as Ubuntu, are known for their user-friendly interface and ease of use, making them a popular choice for beginners. Arch-based distros, such as Arch Linux, are more focused on customization and advanced users. They offer a rolling release model and a more hands-on approach to configuration, making them ideal for those who want to get the most out of their operating system.

Desktop Environments

Cinnamon Desktop Environment (Linux Mint)

KDE Desktop Environment

Unity Desktop Environment (Ubuntu)

Gnome Desktop Environment

xfce Desktop Environment, the most lightweight DE

In addition to the different distros, Linux also offers a variety of desktop environments, which are essentially the graphical user interface (GUI) that the user interacts with. Some of the most popular desktop environments include Gnome, KDE, Xfce, and LXDE. Each of these desktop environments provides a different look and feel, and offers different features and customization options. For example, Gnome is known for its sleek and modern interface, while KDE is known for its customization options and extensive features.

Package Managers

Another key aspect of the Linux operating system is the package manager. A package manager is essentially a tool that helps users install, update, and manage software packages on their system. Linux has several popular package managers, including APT (Debian-based), Pacman (Arch-based), and YUM (Red Hat-based). These package managers make it easy to find, install, and manage software packages, ensuring that users always have the latest version of the software they need.

File Managers

Finally, Linux also offers a variety of file managers, which are essentially tools that help users manage and organize their files and directories. Some of the most popular file managers for Linux include Nautilus (Gnome-based), Dolphin (KDE-based), and Thunar (Xfce-based). These file managers provide a user-friendly interface for managing files and directories, making it easy to find, move, and organize files as needed.

Dolphin File Manager

Nautilus File Manager (Ubuntu)

Nemo File Manager (Linux Mint)

Pantheon File Manager (Elementary OS)

Ranger File Manager, A console FM, Highly customizable.

vifm File Manager another console FM

In conclusion, Linux is a versatile and powerful operating system that is suitable for a wide range of users, from beginners to advanced users. Whether you are looking for an easy-to-use operating system, or you want to take full control of your system, Linux has something to offer. With its variety of distributions, desktop environments, package managers, and file managers, Linux is a flexible and customizable operating system that can be tailored to meet your specific needs and preferences

My Archive extractor

2022-12-15T17:54:56+00:00

My personal archive extractor. it's a bash script that simply creates a directory and extract the archive file in int and it supports most of the archive filetypes:

    

#!/bin/bash
file="$1"

SCRIPTNAME="${0##*/}"

err() {
    printf >&2 "$SCRIPTNAME: $*\n"
    exit 1
}

file="$(readlink -f "$file")"
mkdir "$file-extDir" 2>/dev/null
dir="$file-extDir"
case "$file" in
    *.tar.bz2)   tar -xjf        "$file"  -C "$dir"    ;;
    *.tar.gz)    tar -xzf        "$file"  -C "$dir"    ;;
    *.tar.lz)    tar --lzip -xvf "$file"  -C "$dir"    ;;
    *.bz2)       bunzip2         "$file"               ;;
    *.rar)       unrar x         "$file"               ;;
    *.gz)        gunzip          "$file"               ;;
    *.tar)       tar xf          "$file"  -C "$dir"    ;;
    *.tbz2)      tar xjf         "$file"  -C "$dir"    ;;
    *.tgz)       tar xzf         "$file"  -C "$dir"    ;;
    *.zip)       unzip           "$file"  -d "$dir"    ;;
    *.Z)         uncompress      "$file"               ;;
    *.7z)        7z x            "$file"  -o"$dir"    ;;
    *.iso)       7z x            "$file"  -o"$dir"    ;;
    *)           echo "'$file' cannot be extracted by $SCRIPTNAME" ;;
esac

you can make an alias for it in your .bashrc or .zshrc files like so

    

alias x='/home/mosaid/path/to/extract.sh'

it works great with ranger file manager. all you have to do is add the following line to ~/.config/ranger/rc.conf

    

map xx  shell ${HOME}/path/to/extract.sh %s

sed command: A comprehensive guide

2021-11-08T21:29:57+00:00

sed is a stream editor. A stream editor is used to perform basic text transformations on an input stream (a file or input from a pipeline). While in some ways similar to an editor which permits scripted edits (such as ed), sed works by making only one pass over the input(s), and is consequently more efficient. But it is sed's ability to filter text in a pipeline which particularly distinguishes it from other types of editors.

in this article I will show you the power of sed and how easy and convinient it is to edit text files. so lets get to it

Search and replace

this is one of the basic uses of sed . you will find yourself using this a lot

the way we use this command is: sed 's/pattern/replacement/'. the character / can be any character you want but it will result in an error if your text contains the said character so if you're dealing with a text file containing paths, ie a lot of / character , it is advised to use another character like so: sed 's|day|night|' another thing is that you can add a "g" at the end of the command to make it global or greedy, meaning change all occurences of the pattern not just the first one, like so

    

echo "good day to you Ser, and good day to you Madame" | sed 's/day/night/'
# the result will be:
 good night to you Ser, and good day to you Madame
echo "good day to you Ser, and good day to you Madame" | sed 's/day/night/g'
# the result will be:
 good night to you Ser, and good night to you Madame

Search and replace: regular expressions

you can search using literal words or regular expressions, here are a few symbols if you are not familiar with reg ex: ^ means the beginning of the line, $ the end of the line, . "dot" means every character

The following will make all lines of the file between double quotes, by inserting " at the beginning of the line and at the end

    

# insert double quote " at the beginning of the line
# the -i means change the actual file: performe the changes in place instead of printing the result to stdout
sed -i 's/^/"/'  myfile
# insert double quote " at the end of the line, this can be used to append to a line
sed -i 's/$/"/'  myfile
echo {a..z} | sed -E 's/^.{20}//'
# remove the first 20 characters: k l m n o p q r s t u v w x y z

Search and replace: keep and reuse a pattern

you can search for a pattern and reuse it as much as you like, but to do so you need to use sed with the argument -E which tells it that we want to use extended regular expressions. we do this by surrending the patterns with () like so.

    

echo "day and night" | sed -E 's/(and)/\1 \1 \1/'
# day and and and night

consider a line containing the following :

hello 1234 ladies and gentlmen, welcome

we will apply the follwoing sed command to it :

sed -E 's/(^[^ ]*) ([0-9]*) (.*)and (.*)$/\2 \1 \3 AND :\2: \4 \1 + \3/'

Explanation:

^[^ ]* : means from the beginning of the line ^, any non ^ space characters ie [^ ] or more * . this will match "hello" at the beginning of the line
then space and then
[0-9]* : means any numeric character [0-9] or more * . this will match 1234
then space and then
(.*) : means every character "." or more "*", this will match "ladies ", notice the space after ladies
then "and" then space
(.*)$ : finally every character untill the end of the line "$", this will match "gentlmen, welcome"

the parentheses () are not included in the patterns unless we escape them with $ and $. each opening and closing parenthesis make a pattern that will be assigned an index starting from \1 . in the example above we have 4 of them and we can use them however we want in the replacement. this will produce

1234 hello ladies  AND :1234: gentlmen, welcome hello + ladies

Operating on lines : by line numbers

The sed commands affect all the lines of the file unless told otherwise. the "s" command for search and replace for instance can be told to operate on a single line or a range of lines like so:

    

# replace day by night only on the first line
sed '1s/day/night/' file
# do the same but on the last line
sed '$s/day/night/' file
# replace day by night in the lines from line 3 to line 7
sed '3,7s/day/night/' file

Let's say we want to print only specific lines of a file. we need to tell sed to suppress printing the output by the argument -n and then use the command "p" to print the output we want:

    

# only print the 2nd line:
sed -n '2p' file
# only print lines 3 to 7
sed -n '3,7p' file
# print from the line 10 to the last line
sed '10,$p' file

there is also the "d" command to delete lines by their numbers, it behaves just like the "p" command above. PS no need to suppress the output by -n when you are deleting lines, unless you want to, of course.

Operating on lines : by patterns

What if you want to operate on specific lines but you don't know their line numbers for whatever reason. sed of course gives you the choice to operate on lines using patterns. consider a file containing the following lines

dear diary.
day 1 : we went camping outside to spend 7 days in the forest

and then we needed to go fishing in the forest

day 2 : it was raining all day
day 3 : trip canceled

operating on lines by patterns:

    

# print lines containing "forest"
sed -n '/forest/p' file
# delete everything between "day 1" and "day 2"
sed '/day 1/,/day 2/d' file
# delete empty lines, ie lines that has nothing between the start ^ and the end $
sed '/^$/d' file
# or lines containing only spaces
sed '/^[ ]*$/d' file

When we are dealing with lines with patterns or a range of lines, the delimiter character is "/" if we need to change it. we have to escape it with "\" like so: sed -n '\XhelloXp' file. the sed character is "X" . this will only print lines containing the word "hello"

The following example will replace "fishing" by "hunting" in lines between "day 1" and "day 3"

    

sed '/day 1/,/day 3/s/fishing/hunting/' file
# combining the above with p to only print these lines after the change
sed -n '/day 1/,/day 3/{s/fishing/hunting/;p}' file

in the second example above, we can combine as many commands as we want inside the {} and separate them by a semicolon ";". these commands can be multiple search and replace or "p" for printing or "d" for deleting, or any other commands that we'll show later

Inserting text before or after a line: by line number

sed of course can insert text in a specific line of our file, and here is how we can do it

    

# insert before line 1, ie at the beginning of the file
sed '1ithis text will be inserted at the beginning\nand this is a new line' file
# insert after the 3rd line
sed '3athis will be added after the 3rd line' file

Notice that there is no need for spaces or anything. sed will read the number, then the "i" for insertion before or "a" for after. and then you can add your text. in a shell script with a string variable containing text and some special characters, it was not consistent and sometimes it throws some errors, so for complicated and multiline text that needs to be inserted. I use "ed the standard editor" which is an awesome tool and an ancestor of all the text editors out there (sed, grep, awk, vim ...). the ed command needs its own article, maybe it will be next

Inserting text before or after a line: by pattern

Inserting before or after a line can also be done by finding the line by a specific pattern or regular expression.

    

# insert before the line containing "day 2"
sed -i '/day 2/i these lines describe actions done before day 2' file
# how about the crazy idea of inserting after every line containing the word "forest"
sed -i '/forest/a hello nature\nhello world' file

Advanced stuff:

at this point we need an in depth understanding of the inner workings of sed command. sed iterates over the file line by line. when a line is read. it goes into a space called "pattern space". it is in this pattern space that sed applies the instructions and commands we provide. be it s, p ,d or any other command. after applying the commands on the lines in the pattern space the result is then printed to the output. then the pattern space is emptied for the next line/lines of the file. and the cycle continues until the end of the file.
there is another space in sed. it is called "hold space". any line that is stored in the hold space is not operated upon by our commands. as the name suggests, the lines in the hold space are on hold and the stay as they are untill we get them back to the pattern space

the following commands are for the pattern and hold space. and are illustrated in the picutre above

n N Read/append the next line of input into the pattern space
h H Copy/append pattern space to hold space
g G Copy/append hold space to pattern space
x Exchange the contents of the hold and pattern spaces.

in order to clearly show you examples of using the hold/pattern space. I will introduce the concept of sed scripts. up until now we used sed one liners. ie a block of sed commands inside single ' ' or double quotes " ". but it is possible to write a separate sed script and provide it to sed via the argument "-f"
the following script will not do anything fancy. it will just move the first line of our file to the end making it the last line. also it will change the first occurence of "day" in each line to "night", it will also replace "and" by "AND". it will be done by the command:
sed -f scriptfilename ourfilename

    

# this is a comment in the sed script
# this is a block of commands
1{
    # this block will operate on the first line
    # copy the line from pattern space to hold space
    h
    # then Delete pattern space.  Start next cycle.
    d
}
{
    # do the following for all lines
    s/day/night/
    s/and/AND/
}
${
    # this block will operate on the last line $
    # we get back the first line we stored in the hold space
    G
    # magiscule G will append to pattern space
    # miniscule g will erase the pattern space and replace it
    # with what is stored in hold space
}

Labels and branching

if we are in a situation where we need to repeat a set of commands or instructions, we can make them in a label, and then instruct sed to "branch to this label", ie go to this label. and repeat it again. this script shows us how to read all the lines in a file and after that we replace all the new line characters with spaces, thus making it a single line file. if you are familiar with windows batch scripting, this is the same concept

    

# we make a new label using the colon ":" then a character as the name
# of the label
:a
# append the next line of the file into the pattern space
N
# unless this is the last line "$!" means not last line
# branch to label a "ba" go to label a and repeat the comands after the label
# in this example a single instruction: N
$!ba
# when we exit the loop, ie we reach the last line and the end of the file
# we substitute the new line character "\n" by space
s/\n/ /g

the above script can be compressed into a one liner: sed ':a;N;$!ba;s/\n//g' file

A few useful sed examples

remove leading spaces: sed -E 's/^\s+//g' file

remove leading spaces: sed 's/^[ \t]*//g' file

remove html tags: sed 's/<[^>]*>//g' file.html

change in place and keep backup: sed -i.bak '' file

And there you have it. I believe I covered everything there is to know about sed command. if I overlooked or forgot something. please tell me in the comments

Linux Directory Tree Structure

2021-11-04T19:05:21+00:00

First is the root directory, which is often noted by a forward slash (/). This houses everything on your Linux system, and since Linux gives total control to its user. you can issue the following command: sudo rm -rf / to completely remove everything (AND I MEAN EVERYTHING) in your computer . WARNING: do not try this command in your computer!.

Next up is /bin, which contains all essential executable binaries that are required for a system to function in single-user mode. These executables aren't user applications, but essential commands that are used by the system (but can also be used by users), such as less and ip.

Next is /boot, which contains all the files required for the system to boot. You'll then find /dev, which contains several special device files, such as /dev/sda, which represent hardware and virtual devices.

The /etc directory is where all of the system-wide configuration files for applications and services are.

The /dev directory consists of files that represent devices that are attached to the local system. However, these are not regular files that a user can read and write to; these files are called devices files or special files. Device files are abstractions of standard devices that applications interact with via I/O system calls. They are representations of hardware devices.

The home directory, which is /home, houses all personal files and directories for the users. such as Music, Documents and Download directories, in my system for example I have this "/home/mosaid/Documents" directory which contains my documents

The /lib directory contains the library files (which are used by essential binaries).

There's also the /lost+found directory, which stores recovered files that are used in case of a system crash.

The /media directory contains all subdirectories for removable devices (such as external drives).

The /opt directory is for optional packages and serves as a common location for proprietary software that doesn't tend to follow the standard file system hierarchy.

System and process information files are stored in /proc.

The Root user home directory is isolated from home and is found in /root. the root user is called the super user, it has the highest prevelege in the linux system, when we want to install a program for instance we precede our command by the word "sudo" which means do this command as a super user

Applications can store transient files for sockets and process IDs in the /run directory.

The /sbin directory houses more executable binary files, but these are those that are used primarily for system administration.

The Service Data folder (/srv) is a location that houses data for services that are provided by the system (such as for the Apache webserver).

All temporary files are stored in /tmp and are deleted when the system is restarted.

User binaries (applications used only by the user and not by the system) are stored in /usr.

And finally, the /var directory houses all variable data files, such as log files (in /var/log) as well as the Apache document root (in /var/www/html/).

And here you have it, that was the linux filesystem and directory heirarchy. everytime you want to know your position in this directory tree you can use the command pwd which will print current directory and will let you know where you are.

The best configuration for mpd music player with ncmpcpp and mpc (2020)

2020-09-06T18:40:05+00:00

mpd stands for music player daemon, it is a music player and as its name suggests it is a daemon, ie a process that runs in the background and you cannot interact with it directly.
the music player daemon needs a way to control it. comes ncmpcpp is a command line graphical interface built for mpd and highly configurable. with beautiful colors and features. you can control mpd with mpc - music player control. is a command line tool to control the music player from the command line via sockets.

In this article I give you the enitre configuration for mpd, mpc and ncmpcpp and my personal bash script to add more simplicity to using mpc to control the music player daemon via simple and short commands.

Installing mpd, mpc and ncmpcpp

it is extremely easy to install these 3 packages :



# debian based distributions:
$ sudo apt install mpd mpc ncmpcpp

# Arch based distributions:
$ sudo pacman -S mpd mpc ncmpcpp

Configuring mpd:

we create a ".mpd" directory anywhere we want, preferably in our home directly. then we create mpd.conf file and we put the following lines in it :



music_directory         "/home/myusername/path/to/My Music"
playlist_directory      "/home/myusername/.mpd/playlists"
db_file                 "/home/myusername/.mpd/mpd.db"
log_file                "/tmp/mpd.log"
pid_file                "/home/myusername/.mpd/mpd.pid"
state_file              "/home/myusername/.mpd/mpdstate"
restore_paused          "yes"
auto_update             "yes"
audio_output {
    type "pulse"
    name "pulse audio"
}
audio_output {
    type                 "fifo"
    name                 "my_fifo"
    path                 "/tmp/mpd.fifo"
    format               "44100:16:2"
}

bind_to_address          "127.0.0.1"
port                     "6601"

the above config file will set the path to our music directory, and an optional yet very important path to our custom playlists directory. the other files will be created dynamically as the mpd runs.
While running in the background, mpd acts like a server running in our localhost and can be controlled from port "6601", we can choose any port we want as long as it is not used by some other application.
we execute mpd only once, onboot or when we want to play some music or in anyway we want. by issuing this command:



$ mpd /home/myusername/.mpd/mpd.conf

Configuring ncmpcpp:

Configuring ncmpcpp is just as easy as Configuring mpd, however it would take a lot of trial and error to get the perfect colors and layout of the user interface.
We begin by creating a ".ncmpcpp" directory anywhere we want, we may even name it something else entirely. the name is only to remind us that it is the directory for ncmpcpp . then we create a config file in it and put the following in it:



##### connection settings #####
mpd_host = "localhost"
mpd_port = "6601"
mpd_music_dir = "/home/myusername/Music/My Music"
lyrics_directory = "/home/myusername/Music/My Music/nmcpplyrics"
mpd_connection_timeout = "5"
mpd_crossfade_time = "1"

ncmpcpp_directory = "/home/myusername/.ncmpcpp"

##### delays #####
playlist_disable_highlight_delay = "1"
message_delay_time = "4"

##### window interface #####
user_interface = classic
header_visibility = yes
titles_visibility = no
cyclic_scrolling = yes
header_text_scrolling = yes
playlist_display_mode = "columns"
browser_playlist_prefix = "$2playlist$9 "
alternative_header_first_line_format = "{%t}"
alternative_header_second_line_format = "$7{%a} - $5{%b} $8{(%y)}"
song_window_title_format = "{%a - }{%t}|{%f}"
##### song list format #####
song_list_format = "{%a - %t}|{$8%f$9}{$3(%l)$9}"
song_library_format = "{%n - }{%t}|{%f}"
selected_item_prefix = "$6"
selected_item_suffix = "$9"
now_playing_prefix = "$b$r"
now_playing_suffix = "$/b$/r"
song_status_format = "{(%l) }{%a - }{%t}|{%f}"
playlist_shorten_total_times = yes
song_columns_list_format = "(30)[52]{a} (30)[4]{t} (7f)[88]{l}"

###### various settings #####
#incremental_seeking = yes
#seek_time = "1"
#autocenter_mode = yes
#centered_cursor = yes
#default_place_to_search_in = "database"
#default_find_mode = "wrapped"
#default_tag_editor_pattern = "%n - %t"
#header_visibility = yes
#header_text_scrolling = yes
#cyclic_scrolling = no
#statusbar_visibility = yes
#follow_now_playing_lyrics = yes
#clock_display_seconds = yes
#enable_window_title = yes
#user_interface = "alternative"
#progressbar_look = "=>"
progressbar_look = "─╼-"
seek_time = 10
#external_editor = "vim"
#use_console_editor = yes
#locked_screen_width_part = "60"


##### colors definitions #####
colors_enabled = yes
empty_tag_color = "52"
header_window_color = "52"
volume_color = "11"
state_line_color = "yellow"
state_flags_color = "11"
main_window_color = "52"
color1 = "white"
color2 = "green"
progressbar_color = "11"
progressbar_elapsed_color = "yellow"
statusbar_color = "52"
visualizer_color = "11"
window_border_color = "green"
active_window_border = "11"
alternative_ui_separator_color = "black"


#### visualizer ##############
visualizer_in_stereo = yes
visualizer_fifo_path = "/tmp/mpd.fifo"
visualizer_output_name = "my_fifo"
visualizer_sync_interval = "30"
visualizer_type = "spectrum"
visualizer_look = "◆▋"


######## more ######
external_editor = vim
use_console_editor = yes

The important part of that config file is the connection settings. Obviously they need to match mpd's config file: the host, the port and the music directory ... need to be the same. all the remaining configs are just to tweak the interface. the above config will produce the following interface:

mpc does not require any configuration. all we need is to provide the host and port in which mpd is running when we try to control it, the following command will toggle the music player play/pause from the terminal :



$ mpc --host=127.0.0.1 --port=6601  toggle

one can simply alias the above command to a more convenient one, or make a shell script to control mpd using mpc, and that's what I did in the following script:



#!/bin/bash
function printhelp () {
  printf '\033[1;33m  %-15s\t\033[1;37m%s\n' "$1" "$2"
}
mympc=' mpc --host=127.0.0.1 --port=6601 '
case "$1" in
    "" )  $mympc -q  next  ;;
    "c")  ;;
    "s") if [ -z "$2" ]
        then $mympc -q  stop
        else
             ii=0
             for i do
            if (($ii!=0)) ; then query+="$i|" ; fi
            ii=$((ii+1))
             done
             query=${query::-1}
             "$0" ll |grep --color=always -i -E "$query"| sort -n | uniq
         fi
         exit ;;
       "pp"|"m") if ! `$mympc |grep -F "playing">/dev/null`
        then $mympc -q play
        else $mympc -q pause
         fi
    ;;
    "p") $mympc -q  prev ;;
    "n") $mympc -q  next ;;
    "v") $mympc   volume +2|awk 'NR==3{print $2}' ;;
    "vv") $mympc   volume -2|awk 'NR==3{print $2}' ;;
    "h"|"H"|"help")
        printf "\t \033[1;32m my script to control mpd \033[1m\n"
        printhelp  "h,H,help" "print this help"
        printhelp  "c" "currently playing song"
        printhelp  "" "play next"
        printhelp  "pp,m" "play/pause"
        printhelp  "p" "previous"
        printhelp  "n" "next"
        printhelp  "v" "volume +2"
        printhelp  "vv" "volume -2"
        printhelp  "s" "stop"
        printhelp  "s   [pattern]" "search index of song(s) with pattern(s)"
        printhelp  "[number]" "play nth song"
        printhelp  "a   [patterns]" "add songs w/ patter(n) to curr playlist"
        printhelp  "ll" "print current playlists"
        printhelp  "d" "remove current song from playlist"
        printhelp  "ss  [patterns]" "print result of search pattern(s)"
        printhelp  "sl  [patterns]" "play songs with pattern(s)"
        printhelp  "ssl [patterns]" "print then play songs with pattern(s)"
        printhelp  "save [name]" "save current playlist"
        printhelp  "l   [playlist]" "load playlist"
        printhelp  "*" "other commands accepted by mpc"
    exit
    ;;
    "a") $mympc search any "$2" | $mympc add  ;;
       "ll") index=$($mympc status -f "%position%" |head -1)
         $mympc playlist|awk '{$0=substr($0,0,60) ; print $0 }'\
           |nl| less +"$index"
    exit
    ;;
       "sl"|"ss"|"ssl")
         ii=0
         ss=$( $mympc search  any "")
         ss+="\n"
         for i do
        if (($ii!=0)) ; then
        ss+=$( $mympc search  any "$i")
        ss+="\n"
        query+="$i|"
        fi
        ii=$((ii+1))
         done
         query=${query::-1}
         if [[ "$1" == "ss" || "$1" == "ssl" ]] ; then
             printf "$ss" |grep --color=always -i -E "$query"| sort -n | uniq
         fi
         if [[ "$1" == "sl" || "$1" == "ssl" ]] ; then
             printf "$ss" |grep -i -E "$query" | sort -n | uniq >| "$HOME/.mpd/playlist/tmp.m3u"
             "$0" l tmp|grep -v ^loading
             rm "$HOME/.mpd/playlist/tmp.m3u"
         fi
    exit
    ;;
    "save") $mympc rm "$2" 2>/dev/null; $mympc save "$2" ;;
    "l") $mympc -q clear
         $mympc -q load $2
         $mympc -q play ;;
    "d")
    index=$($mympc status -f "%position%" |head -1)
    CURRENT="$( $mympc -f "%file%" playlist | sha512sum )"
    while read -r line
    do
        i="$( $mympc -f "%file%" playlist $line | sha512sum )"
        if [ "$i" = "$CURRENT" ]; then
        break
        fi
    done <<< "$( $mympc lsplaylist )"
     $mympc del 0
     $mympc rm "$line"
     $mympc save "$line"
     $mympc -q clear
     echo "removed from $line"
     $mympc -q load "$line"
     $mympc -q play $index
     exit
     ;;
     *)
     number='^[0-9]+$'
     if [[ $1 =~ $number ]]
     then $mympc -q play "$1"
     else $mympc  "$@"
     fi
     exit
     ;;
     esac
     title=$($mympc status -f "%title%" |head -1)
     artist=$($mympc status -f "%artist%" |head -1)
     file=$($mympc status -f "%file%" |head -1)
     index=$($mympc status -f "%position%" |head -1)
     size=$($mympc status |awk 'NR==2{print $2}'|cut -d'/' -f2)
     stats=$( $mympc status |awk 'NR==2{printf("%s - %s",$2,$3) }' )
     stats=${stats:1}
     if ! [[ -z "$artist" && -z "$title" ]]
     then str="$artist - ${title##*/}"
      else str="${file##*/}"
    fi
    echo "$stats # $str"

the above script looks like :

We can search single or multiple words queries:

Everything you need to know about strings manipulation in Bash

2020-08-28T12:51:57+00:00

One of the best things in Bash is the extensive tools we can use to manipulate strings. you can extract substrings , replace or delete them, and do much more.
This will be our string to manipulate for this tutorial:



#!/bin/sh
str=/home/mosaid/Documents/Bash/Bashstrings.sh
#   0123456789.....
#   0-based indexing.

Get Length of string



echo ${#str}        #42

Get 5 chars starting from 0



echo ${str:0:5}      # /home

Get everything after the 5th char



echo ${str:5}      # /mosaid/Documents/Bash/Bashstrings.sh

backward positioning: get the last 14 chars

we use parentheses or a space to delimit the negative sign for the position parameter when we are backward positioning:



echo ${str:(-14)}      # Bashstrings.sh
echo ${str: -14}       # Bashstrings.sh

substrings: forward search

remove everything before ( including ) the first occurrence of "Bash" :



echo ${str#*Bash}      # /Bashstrings.sh

remove everything untill (and including) the last occurrence of "Bash" :



echo ${str##*Bash}      # strings.sh

we can use the same to extract the extension: remove everything until the last dot "."
or to extract the file name from the path by removing everything untill the last "/":



echo ${str##*.}      # sh
echo ${str##*/}      # Bashstring.sh

substrings: backward search

starting from the end remove everything after (including) the word "Bash":



echo ${str%Bash*}      # /home/mosaid/Documents/Bash/

we can use it to extract the directory path :
starting from the end, removing everything after the first occurrence of "/"



echo ${str%%/*}      # /home/mosaid/Documents/Bash/

substrings: replace

first example : replace the first occurrence of "Bash" with "Shell Scripting"
second example: replace all occurrences of "Bash" with "Shell"



echo ${str/Bash/Shell Scripting}    # /home/mosaid/Documents/Shell Scripting/Bashstrings.sh
echo ${str//Bash/Shell}             # /home/mosaid/Documents/Shell/Shellstrings.sh

if we want to use the backward slash "/" as a pattern we need to escape it with a forward slash "\":
replace all "/" with "@"



echo ${str//\//@}       # @home@mosaid@Documents@Bash@Bashstrings.sh

we can make some/all chars uppercase or lowercase:



str="Hello, Welcome to LINUX, Bash strings"

#convert the first char to uppercase
echo ${str^}

#convert all chars to uppercase
echo ${str^^}

#convert the characters c,s and m to uppercase
echo ${str^^[csm]}

#convert the first char to lowercase
echo ${str,}

#convert all chars to lowercase
echo ${str,,}

#convert the characters N,U and S to lowercase
echo ${str,,[NUS]}

delimit string and divide it into variables

Here, the delimitter (separator) is the comma ,



str="Hello, Welcome to LINUX, Bash strings"

IFS=, read -r x y z <<< "$str"

echo x = $x         # Hello
echo y = $y         # Welcome to LINUX
echo z = $z         # Bash strings

delimit string and divide it into an array



str="Hello, Welcome to LINUX, Bash strings"

IFS=, read -ra arr <<< "$str"

echo ${arr[0]}         # Hello
echo ${arr[1]}         # Welcome to LINUX
echo ${arr[2]}         # Bash strings

With these tools we can manipulate our strings in any way we want, however we might face a situation much complicated where these native Bash strings manipulation tools will not be sufficient, at this point we can use some much more powerful commands like sed or awk.

Bash scripting tutorials: for loop

2020-08-22T18:14:50+00:00

Loops are an important part of any pragramming language, they offer a way to repeat commands or instruction witout repeating lines of code, the for loop comes in diffrent styles in bash scripting

Generally the for loop has the following syntax:

    for var in list
        do
            commands
    done

C style for loop:



for (( i= 0 ; i<=10; i++ )) ; do
    echo $i
done

for loop with basic range:

the following for loop will print numbers from 0 to 10:



for i in {0..10} ; do
    echo $i
done

for loop with range and step:

the following for loop will print the numbers : 0 5 10 15 20, since the step is 5



for i in {0..20..5} ; do
    echo $i
done

We can iterate through the results of a command



for w in $(echo "John Smith Sarah Ashly" ) ; do
    echo "my name is $w"
done

the next for loop will go through html files in a directory and change their extension to php



for f in $(ls dir/*.html) ; do
    mv "$f" "$( basename -s .html $f ).php"
done

Bash scripting tutorials: part 1 - hello world and variables

2020-07-05T18:22:55+00:00

Shell scripting is the language of Linux Command Line, it is the most used language under linux because you can assimilate and use all other langages in your scripts. you can use Python scripts, All the operating system programs and commands, you can even run php scripts right from your terminal or shell scripts.

it is preferable to write shell scripts in a text file with the extension ".sh" for a better text highlighting in the text editors like vim.
shell scripts are just sequences of commands that are executed by the shell interpreter, in our case the shell interpreter is Bash.

Note: Shell can be Bash, zsh, sh or fish... in these tutorials I will be talking about scripts intended for Bash, but there is not much difference between the shells except for sh. which is the legacy shell in all unix systems and it does not support much of the advanced scripting supported bty the other shells.

First Bash script

As the Tradition dictates in all programming langues. Our first program will be a hello world program.
Lets fire up a terminal and create a file and call it first.sh like so :

    
 touch first.sh

Lets write the next two lines in our file:

    
#!/bin/bash
echo "hello world"

Lets write the next two lines in our file:

The first line is called a shabang. it is an instruction to the current shell interpreter that is about to execute our file to use "Bash" as the program to interpret and execute our script. the 2nd line is our message to the world using the command "echo" and we will be using this command a lot.
then we make the file executable. we have the choice to not make it executabe. but then we must pass it as an argument to Bash every time we want to execute it by typing : "bash first.sh".

    
  chmod +x first.sh
  ./first.sh

Variables

All programming languages use variables, and Bash scripting is no exception. for it is the variables that makes the scriptes dynamic and adaptive to their envirement.in Shell scripting there are only two types of variables : integers and strings (of characters) . and Bash scripting has many built in features for maniputating string. we will make a full tutorial about them in future articles

using variables

we can make variables just by giving them a name the starts with with alpha-characters or the underscore character "_" and then asigning a value to the variable with the "=" symbol. like so:

    
var1=123
mytext1="hello world"
echo "$var1 is a number"
echo  $mytext1 is a string echoed without double quotes

we then use them by the dollar "$" sign followed by the variable name , we can use them in other commands like "echo" or any other command.:

    
123 is a number
hello world is a string echoed without double quotes

As you have seen we created our first program and we said hello to the entire world , then we created some variables. the good stuff are yet to come in future articles and then you will witness the full power of Bash scripting.

MOSAID Articles & Tutorials - Linux

KolourPaint: The MS Paint Replacement I Finally Found After 20 Years of Linux

Discovery and First Impressions

Feature Comparison: MS Paint vs. KolourPaint

Daily Workflow Integration

Why Lightweight Tools Matter

Installation

Tradeoffs

Final Thoughts

5 Ultra-Light Linux Distributions for 256 MB – 1 GB RAM Machines as a Child’s First Engineering Workstation

Why Give a Child a Computer That “Can’t Do Anything”

The Hardware Landscape: Why 256 MB Still Matters

Selection Criteria

1. Alpine Linux – The Purpose‑Built Base

2. Puppy Linux – The Portable Workshop

3. Tiny Core Linux – The LEGO Brick of Operating Systems

4. antiX – The “Just Works” Lightweight Legacy

5. SliTaz – The Small‑Footprint Powerhouse

Turning an Old Laptop into a “First Computer” Gift

Performance Considerations and Tuning

The Long‑Term Payoff: Raising Engineers Instead of Consumers

Tradeoffs and When This Approach Does Not Fit

Final Thoughts

5 Reasons Most People Stick With Windows Even Though Linux Is Free

The Linux Paradox

Desktop Computing Is Not a Technical Market

The Power of Defaults

How Governments Were Bought to Embed Windows in Education

Why Linux Won the Server but Not the Desktop

The Difference Between Engineering Merit and Market Dominance

Conclusion

Automating Beautiful Quote Images with LaTeX and Bash

Automating Beautiful Quote Images with LaTeX and Bash

🧠 Overview of the Workflow

⚙️ Script Breakdown

1. Input Handling and Configuration

2. Temporary Workspace and Output Paths

3. Background Image Optimization

4. LaTeX Document Generation

5. Full-Page Background with TikZ

6. Compilation and Export

The Full script

🚀 Why This Script Is Powerful

📌 Final Thoughts

Smart Brightness Control in Linux: Auto-Detect and Manage Backlight Like a Pro

🧠 Understanding the Problem

⚙️ The Smart Brightness Script

⚡ Usage Examples

🔐 Optional: Remove the Need for sudo

🧠 Final Thoughts

🚀 Next Steps

Supercharging Zsh: Practical Functions and Keybindings for Power Users

Introduction

1. Ranger-Powered Directory Switching (Ctrl+O)

2. Edit Command Line in Vim (Ctrl+E)

3. Smarter History with FZF

Ctrl+R — Fuzzy Search History

Directory Jump from History (Ctrl+S / Ctrl+A)

4. Open Recent Files from Vim History (Ctrl+V)

5. Instant Sudo Toggle (Double ESC)

6. High-Performance History Configuration

7. Completion System Tuning

8. Subtle UX Improvements

9. Notes Injection Before Commands

Conclusion

Automating Video Speed-Up and Audio Replacement with FFmpeg and Bash

1. The Complete Script

2. Understanding the Pipeline

3. Why We Remove Audio First

4. The Core Concept: setpts

Advanced Note

5. Looping Audio Without Guessing Duration

Stream Mapping (Important)

6. Temporary Files Strategy

7. Interactive Selection vs Automation

Upgrade: fzf Integration

8. Performance Considerations

9. Turning This Into a Real Tool

10. Where This Fits in Real Workflows

Final Thoughts

The Hardware Landscape: Why 256 MB Still Matters

The `play-ayat` script