Forem: Eshan Roy (eshanized)

I Built an Automated SLM Fine-Tuning Engine with Python and Unsloth 🚀

Eshan Roy (eshanized) — Mon, 19 Jan 2026 21:15:36 +0000

Fine-tuning Small Language Models (SLMs) like Llama 3.2 or Phi-4 is easier than ever thanks to tools like Unsloth. But the setup is still a pain. You have to find the right Colab notebook, format your data into JSONL, debug generic errors, and figure out which model actually fits your use case.

I wanted to fix that friction. So I built SLMGen, an open-source tool that automates the entire process.

Your Data → Best Model → Matched. One notebook. Zero setup.

Here's how I built it and how it works under the hood.

🏗️ The Architecture

SLMGen is a full-stack application:

Backend: Python 3.11 with FastAPI (because Python is the language of AI).
Frontend: Next.js 16 (for a snappy, modern UI).
Authentication: Supabase.
Engine: A custom Recommendation Engine & Notebook Generator.

The core magic happens in libslmgen, the Python backend. Let's dive into the cool parts.

🧠 1. The Recommendation Engine

Most people don't know which model to pick. "Should I use Phi-4 or Llama 3.2? Is Mistral 7B too big for my edge device?"

I built a 100-point scoring system to mathematically answer that question. It analyzes your dataset and intent to pick the perfect model.

Here is the scoring logic from core/recommender.py:

def get_recommendations(task, deployment, stats, characteristics):
    # ...
    # 50 points: Does the model fit the task? (e.g. Code vs Creative Writing)
    task_score = _score_task_fit(model, task)

    # 30 points: Does it fit the hardware? (e.g. Edge vs Cloud)
    deploy_score = _score_deployment_fit(model, deployment)

    # 20 points: Does the data match the model strengths? (e.g. Multilingual -> Qwen)
    data_score = _score_data_fit(model, stats, characteristics)

    total = task_score + deploy_score + data_score
    # ...

It doesn't just guess. It looks at your data features:

Multilingual? → Bonus for Qwen 2.5 (it's great at non-English).
JSON Output? → Bonus for Phi-4 or Qwen (strong structured output).
Edge Deployment? → Big penalty for 7B models, big bonus for Gemma 2B or SmolLM.

🔍 2. Dataset Intelligence

Before you train, you should know what you're training on. SLMGen scans your JSONL file for:

Quality Issues: Duplicates, empty responses, short inputs.
Personality: Is your data "Formal & Expert" or "Casual & Helpful"?
Hallucination Risk: It scans for vague language ("might," "probably") vs. grounded language ("according to," numbers/dates).

This is done via heuristic analysis in core/personality.py and core/risk.py. It's not an LLM judging an LLM—it's fast, deterministic signal processing on text.

🪄 3. Self-Contained Notebooks

This is my favorite feature. Usually, to run a Colab notebook, you have to:

Download a notebook.
Upload your JSONL file to Colab.
Fix the file path in the code.

SLMGen removes steps 2 and 3. It embeds your dataset directly into the notebook as a base64 string.

# From core/notebook.py
def generate_notebook(dataset_jsonl, ...):
    # Encode dataset
    dataset_b64 = base64.b64encode(dataset_jsonl.encode()).decode()

    # Generate Python code cell
    code_cell = f"""
    import base64
    import json

    DATASET_B64 = "{dataset_b64}"

    # Decode on the fly
    dataset_str = base64.b64decode(DATASET_B64).decode()
    raw_data = [json.loads(line) for line in dataset_str.splitlines()]
    """
    # ...

When you open the notebook, you just click "Run All". No file uploads. No path errors. It just works.

⚡ 4. Unsloth Integration

For the actual training, I rely on Unsloth. It makes fine-tuning 2x faster and uses 70% less memory.

SLMGen automatically configures the correct LoRA target modules for every supported model structure (Llama, Phi, Gemma, etc.), so you never face a "layer not found" error.

🌟 Supported Models

Right now, SLMGen supports 11 top-tier SLMs:

Phi-4 Mini (Reasoning powerhouse)
Llama 3.2 (1B/3B)
Gemma 2 (2B)
Mistral 7B
Qwen 2.5 (Best for coding/multilingual)
And more...

💻 Try it out

The project is fully open source. You can run it locally or deploy it yourself.

GitHub: https://github.com/eshanized/slmgen
Live Demo: https://slmgen.vercel.app

I'd love to hear your feedback! If this helps you fine-tune your first model, drop a star on the repo! ⭐

MultiGit: One repository. Infinite destinations

Eshan Roy (eshanized) — Wed, 05 Nov 2025 23:20:32 +0000

MultiGit is a production-ready, cross-platform Git multi-remote synchronization tool built in Rust. It lets you push, pull, and sync your repository across multiple Git hosting platforms—GitHub, GitLab, Bitbucket, Codeberg, and Gitea/Forgejo—with one command.

Available as both multigit and mg commands for your convenience.

Repository: https://github.com/TIVerse/multigit
Crate: https://crates.io/crates/multigit
Docs: https://docs.rs/multigit

Why MultiGit?

You want redundancy and resilience across platforms.
You contribute to both public (GitHub) and internal (GitLab) repos.
You need reliable backups and continuous mirroring.
You want a single workflow to manage many platforms without brittle scripts.

Highlights

Multi-Remote Sync: push/pull/sync to/from multiple remotes simultaneously
Secure by Default: OS keyring integration with encrypted fallback
Fast and Concurrent: Tokio-based async operations with proper concurrency limits
Smart Conflict Handling: detection, reporting, and guided resolution strategies
Daemon Mode: background sync with scheduling, logs, and health checks
Rich CLI UX: progress indicators, pretty output, and JSON mode for automation
Cross-Platform: Linux, macOS, and Windows

Backed by a comprehensive test suite (unit + integration + workflow) and CI.

Quick Start

Install from crates.io:

cargo install multigit

Build from source:

git clone https://github.com/TIVerse/multigit.git
cd multigit
cargo build --release
./target/release/multigit --version
./target/release/mg --version

Initialize in a repository and add remotes:

cd your-repo
mg init

mg remote add github your-username
mg remote add gitlab your-username

# Commit with the interactive Conventional Commit helper
mg cc

# Sync to all remotes
mg sync

# Check status across remotes
mg status

Tip: Use mg for quick typing or multigit in scripts—they are identical binaries.

Core Features

Multi-remote operations: push, pull, fetch, sync
Remote lifecycle: remote add/remove/list/test/update
Conflicts: conflict list and interactive conflict resolve
Automation: daemon start/stop/status/logs with interval-based scheduling
Health and diagnostics: doctor to auto-detect common issues
Developer UX: cc (Conventional Commit helper), log, switch, stash, undo, amend, changelog
Compatibility: pass-through to native git for everything else

Usage Cheatsheet

Initialize and add platforms:

multigit init
multigit remote add github your-username
multigit remote add gitlab your-username
multigit remote add bitbucket your-username
multigit remote add mygitea your-username --url https://gitea.example.com

Sync safely:

# Interactive sync with conflict detection
multigit sync

# Dry run to preview
multigit sync --dry-run

# To force push history (use with caution), use push or mirror:
multigit push --force
multigit mirror --force

Conflicts:

multigit conflict list
multigit conflict resolve

Daemon mode:

multigit daemon start --interval 5
multigit daemon status
multigit daemon logs --lines 100
multigit daemon stop

Conventional commits (interactive):

mg cc

JSON output for automation:

multigit --json status
multigit --json remote list

Configuration

MultiGit uses a hierarchical configuration system:

CLI Flags (highest priority)
Repository config: .multigit/config.toml (project)
User config: ~/.config/multigit/config.toml (global)
Built-in defaults (lowest)

Example ~/.config/multigit/config.toml:

[settings]
default_branch = "main"
parallel_push = true
max_parallel = 4
colored_output = true

[sync]
auto_sync = false
strategy = "fast-forward"
detect_conflicts = true

[security]
auth_backend = "keyring"  # or "encrypted-file"
audit_log = true

[remotes.github]
username = "your-username"
enabled = true
provider = "github"

[remotes.gitlab]
username = "your-username"
api_url = "https://gitlab.com"
enabled = true
provider = "gitlab"

Your repository-local config (created by mg init) lives at .multigit/config.toml.

Security Model

OS Keyring Integration: macOS Keychain, Windows Credential Manager, Linux Secret Service
Encrypted Fallback: age-encrypted local storage when keyring is unavailable
No Plain-Text Secrets: tokens are never stored in plain text
Audit Logging: optional, configurable

Credentials are stored when you add a remote:

multigit remote add github your-username
# You’ll be prompted for a token, stored securely

Architecture (High-Level)

MultiGit follows a modular architecture with a clear separation of concerns. Source files referenced are in the src/ tree.

graph TB
  UI[CLI Commands] --> CORE[Core Engine]
  CORE --> PROVIDERS[Provider Layer]
  CORE --> GIT[Git Operations (git2)]
  CORE --> SECURITY[Security]
  CORE --> DAEMON[Daemon & Scheduler]

  subgraph Core
    CONFIG[core/config.rs]
    AUTH[core/auth.rs]
    SYNC[core/sync_manager.rs]
    CONFLICT[core/conflict_resolver.rs]
    HEALTH[core/health_checker.rs]
  end

  subgraph Providers
    FACTORY[providers/factory.rs]
    GH[providers/github.rs]
    GL[providers/gitlab.rs]
    BB[providers/bitbucket.rs]
    CB[providers/codeberg.rs]
    GE[providers/gitea.rs]
  end

  subgraph Daemon
    SERVICE[daemon/service.rs]
    SCHED[daemon/scheduler.rs]
  end

  UI --> CONFIG
  CONFIG --> SYNC
  AUTH --> PROVIDERS
  SYNC --> GIT
  SYNC --> PROVIDERS
  SYNC --> CONFLICT
  SERVICE --> SYNC

Notable modules:

src/main.rs: CLI command tree (push/pull/fetch/sync/status/remote/daemon/conflict/etc.)
src/core/: configuration, authentication, sync orchestration, conflict resolution
src/providers/: provider trait + concrete implementations (GitHub, GitLab, Bitbucket, Codeberg, Gitea), created via providers::factory
src/daemon/: daemon service and scheduler
src/git/: thin wrapper around git2 for reliable Git operations
src/ui/: formatting, progress indicators, output helpers
src/utils/: error handling, logging (tracing), helpers

How Sync Works

The sync command orchestrates a safe flow:

Load config and current branch
Ensure working directory is clean
Fetch from all enabled remotes
Detect conflicts/divergence
Push to all remotes in parallel with sane concurrency limits
Report per-remote results and update state

// src/cli/commands/sync.rs (excerpt)
let manager = SyncManager::new(".")?.with_max_parallel(config.settings.max_parallel);
let enabled: Vec<String> = config.enabled_remotes().keys().cloned().collect();
let fetch_results = manager.fetch_all(&enabled).await?;
let push_results  = manager.push_all(&branch_name, &enabled).await?;

Interactive Setup & Conventional Commits

multigit setup launches a friendly wizard: select providers, guided token prompts, connection testing, and config persistence. See src/cli/commands/setup.rs.
mg cc opens an interactive Conventional Commit helper with:
- File staging (All or Selectively)
- Type, scope (auto-suggestions), and description validation
- Optional body, breaking change flag, and footer (issues/refs)
- Preview and edit-before-commit

Daemon Mode

Run background syncs on a schedule:

multigit daemon start --interval 5
multigit daemon status
multigit daemon logs --lines 100

Under the hood (src/daemon/):

Interval-based scheduler
Proper termination and PID handling
Invokes real syncs and logs results

For a minimal reproducible pattern, see examples/scheduler_example.rs.

Examples

examples/basic_usage.rs: configure remotes with the Config API
examples/scheduler_example.rs: periodic tasks with the scheduler
examples/ui_formatting.rs: pretty terminal output helpers

Run examples:

cargo run --example basic_usage
cargo run --example scheduler_example
cargo run --example ui_formatting

Testing & CI

Tests: tests/unit/ and tests/integration/ cover core logic, providers, UI formatting, sync manager, and workflows
CI: GitHub Actions build, test, and verify on each change
Developer utilities: verify.sh, coverage reports, and a structured changelog

Performance & Reliability

Concurrency: tokio + semaphore-based parallelism for bounded concurrency
Timeouts: network operations include sensible timeouts and progress callbacks
Accurate metrics: fetch/push feedback and improved commit counting
Robust error model: typed errors (anyhow, thiserror) and structured logging (tracing)

Roadmap

Terminal UI (TUI) dashboard with ratatui
Workspace management for multiple repos
Git LFS and Submodules
Webhook server for push notifications
GUI app (Tauri)

Contributions are welcome—check CONTRIBUTING.md and open a PR.

Get Started Today

Install: cargo install multigit
Initialize: mg init
Add providers: mg remote add <provider> <username>
Sync: mg sync

If you find MultiGit useful, star the repo and share feedback or ideas. Happy syncing!

Unlock clearer Rust dependency insight with dep-insight

Eshan Roy (eshanized) — Tue, 04 Nov 2025 22:35:38 +0000

If you’ve ever felt buried under a sprawling Cargo.lock, wondered “Which crate dragged in all these transitive deps?” or “Why do I have two versions of foo-crate in my workspace?”, then meet dep-insight: a CLI + library tool designed to give you clear, actionable visibility into your Rust project’s dependency graph.

Why I built it

In many non-trivial Rust codebases I work or consult on, I keep seeing the same patterns:

Duplicate crate versions sneaking in (hello, serde 1.0.130 and serde 1.0.131 side by side)
One transitive ancestor crate pulling in dozens of downstream modules, silently ballooning compile times and binary size
License rustle: “Wait, is this dependency licensed permissively? Or do I need to worry?”
Security: “Do we have known vulnerabilities via rustsec in our dependencies?”

In short: I needed clarity. I needed dep-insight.

What it does — and how

At its core, dep-insight does three important jobs:

1. Analyze

You run:

cargo install dep-insight
cd your-rust-workspace/
cargo dep-insight analyze

It walks your Cargo.toml + lockfile, builds the dependency graph, finds duplicates (same crate, multiple versions), flags crates with large transitive footprints, and gathers metadata (licenses, optional RustSec vulnerabilities) when configured.

2. Visualize

Need to show the team a picture rather than a wall of text?

cargo dep-insight visualize --out deps.html --no-open

Generates a self-contained HTML file with an interactive D3.js graph of your crate-dependencies. You can hover, zoom, see “aha” moments like “this one crate is pulling in 45 others”.

3. Integrate & Automate

It outputs JSON too — perfect for CI checks. Want your pull requests to fail if duplicate versions appear? Build automation on top of the JSON output. Want a nightly audit report? Plug it in.
You can also enable the audit feature to incorporate rustsec vulnerability scanning and license checks.

When & how to use it

Pre-release audits: Before tagging a release, run analyze + visualize, inspect large dependency clusters, ask: “Do we really need that crate dragging in a hundred deps?”
CI/PR gate: Hook into the JSON output; fail if duplicates > 0 or forbid non-permissive licenses.
Team onboarding / documentation: Use the HTML visualization as a baseline snapshot of your project’s dependencies—so new devs get a big-picture view fast.
Dependency cleanup sprints: Pick an analysis report, pick the “top heavy” crate(s), ask “Can we remove / replace this with a lighter alternative?” and track progress over time.

What it gets right

It’s written in Rust and built for Rust projects — no awkward cross-language adaptation.
Works offline (by default) unless you enable online features — good for locked-down CI environments.
A dual interface: CLI for devs, JSON for machines, HTML for humans and teams.
Strong “refactoring value”: duplicates + footprint flags directly correlate to maintenance and build-time savings.

What’s still worth improving

Nothing’s perfect, and I see a few areas where dep-insight can push further:

A GitHub Action integration would be killer — e.g., automatically generate the HTML, upload as an artifact, comment on PRs with a summary.
Incremental caching of crates.io metadata would speed large workspace analyses.
A SARIF or compatible standard format for vulnerability/license results (so security dashboards can ingest them) would enhance enterprise adoption.
More examples or boilerplate code showing how to embed the library in custom tooling or dashboards could lower the barrier for consumers.

Bottom line

If your Rust project is more than “a handful of crates”, you’ll likely uncover hidden debt: duplicate versions, unintended heavy subgraphs, license surprises. Half the battle is visibility — knowing what you depend on. dep-insight gives you that visibility, and makes it usable (and shareable) across your team.

Give it a spin:

cargo install dep-insight
cargo dep-insight analyze --json report.json
cargo dep-insight visualize --out deps.html

Inspect the output, share the HTML, ask your team “Do we really need that crate?” and start trimming the unseen baggage.

If you try it and hit weird results, or have ideas for integrations (like GitHub Actions, dashboard plugins, etc), I’d love to hear about them!

Happy refactoring 🙂
— Eshan (CEO @ Tonmoy Infrastructure)

9 Must-Know Python-Pandas Operations for Working with Data

Eshan Roy (eshanized) — Mon, 11 Aug 2025 02:42:15 +0000

Hey folks 👋
It’s been a while since my last post here — but I’m back! 🚀

Today I’m sharing a one-stop Pandas cheat sheet + explanations that I’ve been using in my own projects. Whether you’re importing, cleaning, analyzing, or exporting data, this guide will save you time and clicks.

📥 1. Data Import — Get data into Pandas

pd.read_csv('file.csv')  # Load CSV
pd.read_excel('file.xlsx', sheet_name='Sheet1')  # Load Excel
pd.read_sql(query, connection)  # Run SQL query
pd.read_json('file.json')  # Load JSON
pd.read_parquet('file.parquet')  # Load Parquet

✅ Why: Bring data from almost anywhere into your DataFrame.

🔍 2. Data Selection — Access what you need

df['column']                # Single column
df.loc['row', 'col']        # By label
df.iloc[0:5, 0:2]           # By position
df.query('col > 5')         # SQL-like filter
df[df['col'].isin(['A','B'])]  # Multiple matches

✅ Why: Quickly filter and grab specific rows or columns.

🔄 3. Data Manipulation — Shape your data

df.groupby('col').agg({'col2': ['mean','sum']})  # Group stats
df.merge(df2, on='key', how='left')              # Join data
df.pivot_table(values='val', index='idx')        # Pivot table
df.sort_values(['col1','col2'], ascending=[1,0]) # Sort
df.melt(id_vars=['id'], value_vars=['A','B'])    # Unpivot
df.apply(lambda x: x**2)                         # Apply func

✅ Why: Transform your dataset to match your analysis goals.

📊 4. Statistics — Quick insights

df.describe()                          # Summary stats
df['col'].agg(['mean','median','std']) # Key metrics
df['col'].value_counts(normalize=True) # Value %s
df.corr(method='pearson')              # Correlation
df.cov()                               # Covariance
df.quantile([0.25, 0.5, 0.75])         # Quartiles

✅ Why: Get instant understanding of your data distribution.

🧹 5. Data Cleaning — Make it usable

df.dropna(subset=['col'], how='any')       # Remove NaNs
df.fillna(method='ffill')                  # Fill forward
df.drop_duplicates(subset=['col'])         # Deduplicate
df['col'].replace({'old': 'new'})           # Replace values
df['col'].astype('category')               # Convert type
df.interpolate(method='linear')            # Fill by trend

✅ Why: Reliable data means reliable analysis.

⏳ 6. Time Series — Work with dates

df.resample('M').mean()                     # Monthly avg
df.rolling(window=7).mean()                 # Rolling avg
df.shift(periods=1)                          # Shift data
pd.date_range('2024', periods=12, freq='M') # Date range
df.asfreq('D', method='ffill')               # Daily freq
df['date1'].dt.strftime('%Y-%m-%d')          # Format date

✅ Why: Time-based data often needs resampling or shifting.

✂ 7. String Operations — Text wrangling

df['col'].str.contains('pattern')          # Match
df['col'].str.extract('(\d+)')              # Extract nums
df['col'].str.split('_', 1).str[0]          # Split text
df['col'].str.lower()                       # Lowercase
df['col'].str.strip()                       # Trim spaces
df['col'].str.replace(r'\s+', ' ')          # Normalize spaces

✅ Why: Clean messy text fields directly in Pandas.

🚀 8. Advanced Features — Power moves

df.pipe(func)                              # Chain funcs
pd.eval('df1 + df2')                       # Fast eval
df.memory_usage(deep=True)                 # Memory check
df.select_dtypes(include=['number'])       # Filter types
df.nlargest(5, 'col')                      # Top values
df.explode('col')                          # Expand lists

✅ Why: Write cleaner, faster, and more efficient code.

💾 9. Data Export — Save your work

df.to_csv('output.csv', index=False)               # CSV
df.to_excel('output.xlsx', sheet_name='Sheet1')    # Excel
df.to_parquet('output.parquet')                    # Parquet
df.to_json('output.json', orient='records')        # JSON

✅ Why: Share results in the right format instantly.

💡 Pro Tips

📝 Use .copy() to avoid accidental changes.

🔗 Chain methods for cleaner code.

🗂 Use dtype='category' to save memory.

❌ Avoid inplace=True — reassign instead.

💬 Question for you: Which Pandas trick here do you use the most? Or do you have a favorite that’s not listed? Let’s share and make this an even better cheat sheet. 🚀

Mastering Python Virtual Environments: A Complete Guide

Eshan Roy (eshanized) — Mon, 10 Mar 2025 15:27:13 +0000

Python is a powerful and versatile language, but managing dependencies across multiple projects can become a challenge. This is where Python virtual environments come in handy. In this guide, we’ll explore virtual environments in depth, including their benefits, setup, inner workings, and best practices.

📌 What is a Python Virtual Environment?

A virtual environment is an isolated Python environment where dependencies are installed separately from the system-wide Python installation.

It allows you to:

✅ Maintain project-specific dependencies.

✅ Avoid conflicts between different projects.

✅ Experiment with different package versions safely.

✅ Ensure reproducibility across different environments.

❓ Why Do We Need Virtual Environments?

Without a virtual environment, all Python packages are installed globally, meaning:

🚨 Dependency Conflicts – If two projects require different versions of the same package, one will break.

🚨 System Pollution – Installing packages globally can clutter the system and cause unexpected issues.

🚨 Reproducibility Issues – A project might work on one machine but fail on another due to different package versions.

Using virtual environments ensures each project has its own dependencies, preventing conflicts and improving maintainability.

⚙️ How Does a Virtual Environment Work?

When you create a virtual environment, it essentially replicates the structure of a Python installation but in an isolated manner. Here's how:

1️⃣ Directory Structure

Creating a virtual environment generates a folder (e.g., myenv/) with the following structure:

myenv/
│── bin/ (or Scripts/ on Windows) → Contains the Python binary & activation scripts  
│── lib/ → Contains installed Python packages  
│── include/ → Contains C headers for compiled dependencies  
│── pyvenv.cfg → Configuration file linking the environment to the correct Python version

2️⃣ Activation Mechanism

When you activate a virtual environment:

✔️ The system modifies the PATH to use the Python binary inside myenv/bin (or Scripts/ on Windows).

✔️ pip and all installed packages are scoped within myenv/ instead of affecting global Python.

3️⃣ Installing Packages

When you run:

pip install requests

It installs only inside the lib/ folder of the virtual environment and doesn't affect system-wide Python.

4️⃣ Deactivation

When you deactivate the environment, your shell restores the original PATH, reverting back to system Python.

This isolation ensures each project has its own dependencies and doesn't interfere with others.

🔧 How to Set Up a Python Virtual Environment

1️⃣ Check Your Python Version

Before creating a virtual environment, ensure Python is installed on your system:

python --version

python3 --version

2️⃣ Create a Virtual Environment

Using `venv` (Recommended for Python 3.3+)

The built-in venv module is the recommended way to create virtual environments in Python 3.

python -m venv myenv

python3 -m venv myenv

This will create a directory named myenv containing the isolated Python environment.

Using `virtualenv` (For older versions)

If you're using an older Python version (<3.3) or want additional features, install virtualenv:

pip install virtualenv
virtualenv myenv

3️⃣ Activate the Virtual Environment

On macOS/Linux

source myenv/bin/activate

On Windows (Command Prompt)

myenv\Scripts\activate

On Windows (PowerShell)

myenv\Scripts\Activate.ps1

Once activated, your terminal will show the virtual environment name, indicating that it's active:

(myenv) user@machine:~$

4️⃣ Install Dependencies

Now that your virtual environment is active, install dependencies using pip:

pip install requests flask

To check installed packages:

pip list

5️⃣ Deactivate the Virtual Environment

When you're done working in the virtual environment, deactivate it:

deactivate

🔄 Managing Dependencies with `requirements.txt`

To make your project reproducible, store dependencies in a requirements.txt file.

Save Installed Packages

pip freeze > requirements.txt

Install from `requirements.txt`

pip install -r requirements.txt

🗑️ Deleting a Virtual Environment

To remove a virtual environment, simply delete the directory:

rm -rf myenv  # macOS/Linux
rd /s /q myenv  # Windows

🛠️ Advanced Virtual Environment Management

1️⃣ Using `pyenv` for Managing Python Versions

If you work with multiple Python versions, pyenv helps you switch between them. Install pyenv and create virtual environments with:

pyenv install 3.11.2
pyenv virtualenv 3.11.2 myenv
pyenv activate myenv

2️⃣ Using `pipenv` for Simplified Dependency Management

pipenv combines pip and venv into a single tool. Install and use it like this:

pip install pipenv
pipenv install requests
pipenv shell

🚀 Best Practices for Virtual Environments

✅ Always create a virtual environment for each project.

✅ Use requirements.txt for reproducibility.

✅ Keep virtual environments outside your project directory (e.g., ~/venvs/).

✅ Add myenv/ to .gitignore to avoid committing unnecessary files.

🎯 Conclusion

Python virtual environments are a must-have for efficient project management. By isolating dependencies, they help prevent conflicts and ensure smooth development. Whether you're working on a personal project or collaborating with a team, using virtual environments is a best practice you shouldn't ignore!

🔹 Do you use virtual environments in your projects? Share your experience in the comments! 🚀

Why I Developed Snigdha OS?

Eshan Roy (eshanized) — Wed, 08 Jan 2025 13:31:30 +0000

Developing Snigdha OS has been a journey that combines personal loss, technical passion, and a desire to leave a meaningful legacy. Here’s the story behind why I decided to create this operating system.

1. A Tribute to Mubasshira Snigdha

Life has a way of presenting us with moments that change everything. For me, one such moment was the loss of Mubasshira Snigdha, my late girlfriend. Her untimely passing left a void in my life, but it also ignited a desire to honor her memory in a way that would truly reflect her influence on me.

I named this operating system Snigdha OS as a tribute to her. It is more than just a software project; it’s a testament to the love and inspiration she brought into my life. Every line of code, every feature, and every decision behind Snigdha OS is a way of preserving her legacy.

2. Passion for Open Source and Innovation

As an open-source enthusiast, I’ve always believed in the power of technology to empower people. I wanted Snigdha OS to be more than just another Linux distribution; I envisioned it as a system that combines performance, flexibility, and simplicity to cater to a wide range of users, from developers to cybersecurity professionals to everyday users.

I saw an opportunity to create something unique—an operating system that aligns with modern needs while staying true to the ethos of open source. Snigdha OS embodies my commitment to building a platform that is lightweight, customizable, and accessible.

3. Addressing Gaps in Existing Linux Distributions

While working with various Linux distributions over the years, I noticed certain gaps—whether it was performance issues, lack of customization, or limited usability for specific workflows. With Snigdha OS, I wanted to bridge these gaps by creating a distribution that is:

Performance-Optimized: Leveraging the Linux Zen and LTS kernels for improved responsiveness.
Highly Customizable: Offering a modular approach that allows users to tailor the OS to their needs.
Developer-Friendly: Pre-configured with tools and frameworks that make it ideal for software development and penetration testing.

By focusing on these aspects, I aimed to create a system that not only meets user expectations but exceeds them.

4. Pushing My Technical Boundaries

Developing an operating system is no small feat, and I saw it as a challenge to push my technical boundaries. It was an opportunity to:

Demonstrate my expertise in Linux systems, shell scripting, and software development.
Learn and grow as a developer while solving complex problems.
Build something that reflects my skills and passion for technology.

Snigdha OS became my playground for experimentation and innovation, allowing me to explore new ideas and bring them to life.

5. Building a Legacy

Beyond the technical and emotional aspects, I wanted Snigdha OS to stand as a lasting legacy. It’s not just an operating system; it’s a story. A story of love, loss, and the determination to create something meaningful out of life’s most challenging moments.

I hope Snigdha OS inspires others to pursue their passions and create projects that matter. It’s a reminder that even in the face of adversity, we can build something beautiful and impactful.

Last Words

Snigdha OS is more than just an Arch-based Linux distribution. It’s a reflection of my journey, a tribute to someone I deeply loved, and a contribution to the open-source community. Creating it has been a labor of love, a technical challenge, and a deeply personal mission.

If you’re looking for a performance-driven, customizable, and user-centric operating system, I invite you to try Snigdha OS. It’s not just software; it’s a story, and I’d be honored for you to be part of it.

Install and use VirtualBox on Arch Linux & Snigdha OS

Eshan Roy (eshanized) — Tue, 07 Jan 2025 20:47:46 +0000

To install and use VirtualBox on Arch Linux, you can follow these steps. VirtualBox is available in the Arch User Repository (AUR), and you can install it using pacman or an AUR helper like yay.

1. Install VirtualBox

Using `pacman` (Official Arch repository):

If you're using the VirtualBox version from the official Arch repository, follow these steps:

Update your system:

   sudo pacman -Syu

Install VirtualBox: Install VirtualBox and the required dependencies:

   sudo pacman -S virtualbox

This will install VirtualBox and related tools. However, you will also need to install the kernel headers for your specific kernel version.

Install Kernel Headers:

If you are using the default linux kernel:
```
 sudo pacman -S linux-headers
```
If you are using another kernel, like linux-lts, install the corresponding headers:
```
 sudo pacman -S linux-lts-headers
```

Load the VirtualBox kernel module: After installing VirtualBox, load the necessary kernel modules by running:

   sudo modprobe vboxdrv

If you encounter errors, try to ensure that the correct kernel headers are installed and that your system is using the correct kernel.

Start VirtualBox: Now, you can start VirtualBox from the terminal by typing:

   virtualbox

Using the AUR (if you prefer the AUR version):

The AUR version is often up-to-date with the latest VirtualBox releases. You can install it using an AUR helper such as yay.

Install yay (if you haven't already): If you don’t have yay installed, you can install it using the following command:

   sudo pacman -S yay

Install VirtualBox from AUR: Run the following command to install VirtualBox from the AUR:

   yay -S virtualbox

This will also handle dependencies and kernel headers.

2. Add Your User to the vboxusers Group

To allow your user to use VirtualBox without needing to run it as root, add your user to the vboxusers group:

sudo gpasswd -a $USER vboxusers

You will need to log out and log back in for the changes to take effect.

3. Create a Virtual Machine (VM)

Once VirtualBox is installed and the necessary modules are loaded, you can start creating and managing virtual machines using the VirtualBox GUI or the command line:

Start VirtualBox GUI:
You can launch VirtualBox from the applications menu or by running virtualbox in the terminal.
Create a VM:
In the VirtualBox GUI, click on "New" to create a new virtual machine. You will need to specify:
- Name and type of OS.
- Memory size.
- Virtual hard disk (you can create a new one or use an existing one).
Install an OS on your VM:

Once the VM is created, you can start it and install an operating system on the virtual hard disk.

4. (Optional) Install Extension Pack

To unlock additional features such as USB 2.0/3.0 support, better video support, and remote desktop capabilities, you may want to install the VirtualBox Extension Pack.

Download the Extension Pack from the VirtualBox website: VirtualBox Extension Pack.
Install the Extension Pack:
- After downloading, you can add it to VirtualBox from the GUI by going to File > Preferences > Extensions and clicking the Add button to browse and select the downloaded extension pack file.

Troubleshooting:

Kernel module issues: If you run into issues with loading the vboxdrv module, ensure that you have the correct kernel headers installed and that your kernel matches the one you're using.
Check VirtualBox version compatibility: Ensure that you're running the appropriate version of VirtualBox for your kernel and system setup.

Once everything is set up, you can start using VirtualBox to create and manage virtual machines on your Arch Linux system!

Start Shell Programming: A Beginner's Guide ⚙ [Part-I]

Eshan Roy (eshanized) — Sun, 05 Jan 2025 03:50:08 +0000

Shell programming is a powerful skill for automating tasks, managing systems, and improving your productivity as a developer. If you're new to shell programming, this guide will provide you with a strong foundation to get started.

What Is Shell Programming? 🔧

A shell is a command-line interface (CLI) that allows users to interact with the operating system. Shell programming involves writing scripts in shell scripting languages to automate tasks such as file manipulation, process management, and system monitoring. Popular shells include:

Bash (Bourne Again Shell): Common in Linux and macOS.
Zsh: An enhanced shell with additional features.
Fish: A user-friendly shell with great defaults.
PowerShell: Primarily for Windows but also available on Linux and macOS.

Why Learn Shell Programming? 🌐

Automate Repetitive Tasks: Save time by automating tasks like file backups, deployments, and system monitoring.
System Administration: Manage system processes, users, and configurations.
Enhanced Productivity: Create custom scripts to streamline your workflow.
Foundational Skill: Knowledge of shell programming is invaluable for DevOps, cloud computing, and software development.

Getting Started with Shell Scripting ✨

Step 1: Set Up Your Environment

Choose Your Shell: Most systems use Bash by default. To check your default shell, run:

   echo $SHELL

Editor: Use a text editor like vim, nano, or an IDE like VS Code for scripting.
Permissions: Make your script executable with the chmod command:

   chmod +x script.sh

Step 2: Write Your First Script 🚀

Create a file named hello.sh:

   #!/bin/bash
   echo "Hello, World!"

Run the script:

   ./hello.sh

Step 3: Understand Basic Concepts 🔄

Shebang: The first line (#!/bin/bash) specifies the interpreter.
Comments: Add comments with # to document your script.
Variables:

   NAME="John"
   echo "Hello, $NAME"

User Input:

   read -p "Enter your name: " USERNAME
   echo "Hello, $USERNAME!"

Arithmetic Operations:

   NUM1=5
   NUM2=3
   SUM=$((NUM1 + NUM2))
   echo "Sum: $SUM"

Essential Commands and Syntax 🔗

Control Structures

Conditional Statements:

   if [ condition ]; then
       # commands
   elif [ condition ]; then
       # commands
   else
       # commands
   fi

Example:

   if [ -f "file.txt" ]; then
       echo "file.txt exists."
   else
       echo "file.txt does not exist."
   fi

Loops:

   for i in {1..5}; do
       echo "Iteration $i"
   done

   while [ condition ]; do
       # commands
   done

Example:

   COUNT=1
   while [ $COUNT -le 5 ]; do
       echo "Count: $COUNT"
       COUNT=$((COUNT + 1))
   done

Functions

Encapsulate reusable code:

function greet() {
    echo "Hello, $1!"
}

greet "Alice"
greet "Bob"

Best Practices 🚀

Use Meaningful Variable Names: Avoid confusion with descriptive names.
Error Handling: Check the success of commands using $? or set -e to exit on errors.
Code Readability: Use consistent indentation and comments.
Avoid Hardcoding: Use variables and arguments for flexibility.
Test Your Scripts: Always test in a safe environment before deploying.

Common Use Cases 🛠

File Management:

   for file in *.txt; do
       mv "$file" "${file%.txt}.bak"
   done

System Monitoring:

   echo "Disk Usage:"
   df -h

   echo "Active Processes:"
   ps aux

Data Processing:

   awk '/pattern/ {print $1}' file.txt

Backup Automation:

   BACKUP_DIR="backup_$(date +%Y%m%d)"
   mkdir "$BACKUP_DIR"
   cp *.txt "$BACKUP_DIR"
   echo "Backup completed to $BACKUP_DIR."

Task Scheduling: Use cron for periodic task execution:

   crontab -e
   # Example cron job to run a script every day at 2 AM
   0 2 * * * /path/to/script.sh

Learning Resources 📚

Books:
- "Linux Shell Scripting Cookbook" by Shantanu Tushar
- "Learning the bash Shell" by Cameron Newham
Online Courses:
- Udemy: Bash Scripting and Shell Programming
- Codecademy: Learn the Command Line
Documentation:
- GNU Bash Manual
- Zsh Documentation

Conclusion 🌟

Shell programming opens up a world of automation and efficiency. By mastering the basics and gradually exploring advanced concepts, you can unlock the full potential of your operating system. Start small, practice often, and don’t hesitate to experiment. Happy scripting! 🚀

🌟 Introducing My Open-Source Resume: A Step Toward Transparency and Contribution 🚀

Eshan Roy (eshanized) — Mon, 30 Dec 2024 09:27:18 +0000

Hello, Dev.to! 👋

I’m excited to share my open-source resume project, available on GitHub at eshanized/resume. This project is an attempt to create a personal, transparent, and easily maintainable resume using modern web technologies. 🎉

Why Open Source? 🤔

In an ever-changing tech landscape, your personal brand and resume should be as dynamic and customizable as the tools we use every day. By open-sourcing my resume, I aim to:

Promote transparency: Make my career achievements and projects publicly accessible to peers, recruiters, and anyone interested in my work. 🌐
Contribute to the community: By providing a template that others can fork, modify, and use for their own resumes. 💡
Showcase my skills: This project serves as a technical demonstration of my proficiency in frontend development with React, Vite, Tailwind CSS, and GitHub Pages. 💻

Features ✨

Modern Design: My resume is built with clean, minimal, and responsive design principles using Tailwind CSS. 🎨
Personalized: It's not just a static resume — it’s a living, breathing document that reflects my professional journey, tech skills, and projects. 📈
Customizable: You can fork it and personalize it for your own use, making it an open-source solution for those who want a customizable web-based resume. 🔧
Accessible: Hosted on GitHub Pages, so it’s accessible anytime, anywhere. 🌍

Technologies Used ⚙️

This project utilizes some amazing technologies to ensure that the website is fast, responsive, and easy to maintain:

React: A popular JavaScript library for building user interfaces. ⚛️
Vite: A build tool that significantly improves the development experience with its fast bundling capabilities. ⚡
Tailwind CSS: A utility-first CSS framework that makes styling faster and more efficient. 💨
GitHub Pages: For easy hosting of the static site. 🌐

How It Works ⚡

Clone or fork the repository: https://github.com/eshanized/resume
Customize the src/data/resume.json file to reflect your own career information. 📝
Run pnpm dev to view your changes locally. 🌱
Deploy your updated resume on GitHub Pages for free. 🌍

Roadmap 🛣️

Here are a few features I’m planning to implement in future releases:

Multilingual support: Adding different language options for a wider audience. 🌏
PDF Export: Allow users to download their resume as a PDF. 📄
Enhanced UI: Improving the overall design and adding more sections like portfolio highlights, certifications, and volunteer work. 🎨

How You Can Contribute 🤝

I believe open-source thrives on collaboration, and I’d love to get feedback, ideas, and contributions from others. Here’s how you can help:

Fork the repository and submit pull requests with improvements or fixes. 🍴
Report issues if you encounter bugs or have suggestions for enhancements. 🐛
Star the repository if you find it useful or just want to show some support. ⭐

You can contribute by simply visiting the repository at https://github.com/eshanized/resume.

I hope you find this project helpful and that it sparks your own ideas for building and sharing your resume in a more dynamic and open way. Feel free to reach out with any questions, feedback, or suggestions! 😊

Thanks for reading, and happy coding! 🎉👨‍💻

🚀 Introducing Preadme: Your Ultimate README Generator!

Eshan Roy (eshanized) — Sat, 28 Dec 2024 00:21:45 +0000

Are you tired of manually writing README files for your projects? Does creating a polished, well-structured README feel like a chore? Say hello to Preadme, an open-source web application designed to simplify the process of crafting professional, Markdown-ready README files.

Check out the live demo here: Preadme Demo

GitHub repository: Preadme on GitHub

What is Preadme?

Preadme is a powerful tool for developers, created to streamline the process of README creation. With an intuitive interface, customizable sections, and live preview capabilities, Preadme eliminates the hassle of creating README files manually, ensuring your project documentation always looks professional and comprehensive.

🌟 Key Features

Interactive UI: Craft your README step-by-step with a user-friendly interface.
Customizable Sections: Add, edit, or remove sections like Project Description, Features, Installation, Usage, and more.
Markdown Support: Automatically generates content in Markdown format, ready to be used on GitHub.
Live Preview: Instantly see how your README will look as you customize it.
Download & Export: Save your README as a .md file or copy it directly.
Default Templates: Kickstart your README with pre-defined templates.
Open Source: Contribute to the project and help make it better for everyone!

🛠️ Tech Stack

Preadme is built with modern technologies to ensure performance and scalability:

React for dynamic and interactive user interfaces.
Tailwind CSS for responsive and elegant design.
Vite for fast builds and modern tooling.
React Router for seamless navigation.
Zustand for efficient state management.
Lucide Icons for crisp, modern SVG icons.
React Markdown for parsing and rendering Markdown.

📚 How to Use

Open the live demo or set up the app locally by cloning the repository.
Fill out the sections (Project Name, Description, Tech Stack, etc.) in the intuitive form interface.
Preview your README in real-time and make edits as needed.
Once satisfied, download the .md file or copy the generated content.

💻 Installation

Want to contribute or customize Preadme? Here’s how to set it up locally:

Clone the repository:

git clone https://github.com/eshanized/preadme.git

Navigate to the project directory:
```
cd preadme  
```
Install the dependencies:
```
npm install  
```
Start the development server:
```
npm run dev  
```
Open http://localhost:5173/preadme in your browser to see the application in action.

🧑‍💻 Contributing

Preadme is open source, and we’d love your contributions!

How to contribute:

Fork the repository.
Clone your fork to your local machine.
Create a feature branch for your changes:
```
git checkout -b feature-name  
```
Commit and push your changes:
```
git push origin feature-name  
```
Open a pull request to the main repository.

We welcome bug fixes, feature enhancements, or even ideas for new functionality!

📜 Example Output

Here’s a sample README generated with Preadme:

# Project Name  

## Description  

A brief description of the project.  

## Features  

- Feature 1  
- Feature 2  
- Feature 3  

## Tech Stack  

- React  
- Tailwind CSS  
- Zustand  
- Vite  

## Installation  

1. Clone the repository:  
    ```

bash  
    git clone https://github.com/user/project-name.git


    ```  

2. Install dependencies:  
    ```

bash  
    npm install


    ```  

3. Start the server:  
    ```

bash  
    npm run dev


    ```  

## License  

This project is licensed under the MIT License.

🎉 Why Use Preadme?

With Preadme, you can save time, maintain consistency, and focus on building amazing projects instead of spending hours writing documentation. Whether you’re a solo developer or working on a team, Preadme ensures your project always starts with a great README.

🔗 Useful Links

Live Demo: https://eshanized.github.io/preadme
GitHub Repository: https://github.com/eshanized/preadme
Report Issues: https://github.com/eshanized/preadme/issues

Let us know your thoughts in the comments or open an issue on GitHub. We’d love your feedback and contributions! 🚀

Mastering `sed` Commands and Flags: A Guide to Stream Editing in Linux 🖥️

Eshan Roy (eshanized) — Mon, 09 Dec 2024 09:03:02 +0000

sed (Stream Editor) is one of the most powerful text processing tools in Linux. Whether you're performing basic text replacement, deleting lines, or transforming entire files, sed provides a variety of commands and flags that can be used to manipulate text streams effectively.

In this post, we’ll dive into sed commands and their flags, explore common use cases, and look at examples to make you a sed master! 🛠️

🎯 Common `sed` Commands & Flags Explained

1. Substitution Command (`s`)

The substitution command is by far the most commonly used in sed. It searches for a pattern and replaces it with a replacement string.

Syntax:

sed 's/pattern/replacement/flags' file

Example: Basic Substitution

sed 's/foo/bar/' file.txt

This replaces the first occurrence of foo with bar in each line of file.txt.

Example: Global Substitution

sed 's/foo/bar/g' file.txt

Replaces all occurrences of foo with bar in each line.

Example: Case-Insensitive Substitution

sed 's/foo/bar/i' file.txt

Replaces foo with bar regardless of case (i.e., Foo, fOO, etc., are also replaced).

Example: N-th Occurrence Substitution

sed 's/foo/bar/2' file.txt

Replaces the second occurrence of foo with bar in each line.

2. Delete Command (`d`)

The delete command removes lines that match a given pattern or condition.

Syntax:

sed '/pattern/d' file

Example: Delete Lines with a Specific Word

sed '/error/d' file.txt

This deletes all lines containing the word error from file.txt.

Example: Delete Blank Lines

sed '/^$/d' file.txt

Deletes blank lines (lines with no content).

Example: Delete Lines Starting with a Number

sed '/^[0-9]/d' file.txt

Deletes all lines starting with a digit.

3. Print Command (`p`)

The print command allows you to print lines matching a given pattern. It is often used with the -n flag to suppress the default behavior of printing all lines.

Syntax:

sed -n '/pattern/p' file

Example: Print Lines Containing a Specific Word

sed -n '/error/p' file.txt

This prints only the lines containing the word error.

Example: Print Matching Lines with the Next Line

sed -n '/error/{N; p}' file.txt

Prints the matching lines along with the next line (this uses the N command to append the next line to the pattern space).

4. Insert Command (`i`)

The insert command adds a line before the specified line number or pattern.

Syntax:

sed 'line_number i\text_to_insert' file

Example: Insert Text Before a Line

sed '2i\This is inserted before line 2' file.txt

Inserts text before line 2.

Example: Insert Text Before a Matching Pattern

sed '/error/i\This is an error message' file.txt

Inserts "This is an error message" before every line containing error.

5. Append Command (`a`)

The append command adds a new line after the specified line number or pattern.

Syntax:

sed 'line_number a\text_to_append' file

Example: Append Text After a Line

sed '2a\This is appended after line 2' file.txt

Appends text after line 2.

Example: Append Text After a Matching Pattern

sed '/error/a\This is an error resolution step' file.txt

Appends "This is an error resolution step" after every line containing error.

6. Change Command (`c`)

The change command replaces the entire content of a line with new text.

Syntax:

sed 'line_number c\new_text' file

Example: Change Content of a Line

sed '2c\This is the new content for line 2' file.txt

Replaces the content of line 2 with This is the new content for line 2.

Example: Replace Lines Matching a Pattern

sed '/error/c\Critical error occurred' file.txt

Replaces all lines containing error with Critical error occurred.

7. Address Ranges

You can apply sed commands to a range of lines using either line numbers or patterns.

Syntax for Line Numbers:

sed 'start_line,end_line command' file

Example: Delete Lines 2 to 4

sed '2,4d' file.txt

Deletes lines 2 to 4 from file.txt.

Syntax for Pattern-based Range:

sed '/start_pattern/,/end_pattern/d' file

Example: Delete Lines Between Patterns

sed '/start/,/end/d' file.txt

Deletes lines between (and including) the first occurrence of start and end.

8. Multiple Commands with `-e` Flag

The -e flag allows you to execute multiple commands sequentially.

Syntax:

sed -e 'command1' -e 'command2' file

Example:

sed -e 's/foo/bar/' -e 's/baz/qux/' file.txt

First, it replaces foo with bar, then it replaces baz with qux.

9. Suppress Output with `-n` Flag

By default, sed prints every line. The -n flag suppresses this, allowing you to print only the lines you need.

Syntax:

sed -n 'pattern p' file

Example:

sed -n '/pattern/p' file.txt

Prints only the lines containing pattern.

10. In-Place Editing with `-i` Flag

The -i flag enables in-place editing, meaning the file is modified directly without needing redirection.

Syntax:

sed -i 's/foo/bar/g' file

Example: In-Place Substitution

sed -i 's/foo/bar/g' file.txt

Replaces all occurrences of foo with bar and saves the changes to file.txt.

Example: In-Place Editing with Backup

sed -i.bak 's/foo/bar/g' file.txt

Creates a backup file file.txt.bak before making the substitution.

11. Extended Regular Expressions with `-E` Flag

To enable extended regular expressions (ERE) in sed, use the -E flag. ERE allows more powerful patterns, such as +, ?, and |.

Syntax:

sed -E 's/[0-9]+/number/' file

Example:

sed -E 's/\b[0-9]{3}\b/NUMBER/' file.txt

Replaces any 3-digit number with NUMBER.

12. Escaping Special Characters

sed treats certain characters (like /, &, and \) as special. To use them literally, you must escape them with a backslash (\).

Example with Special Characters:

sed 's/foo/bar\&baz/' file.txt

Replaces foo with bar&baz (escaping &).

🚀 Conclusion

sed is an incredibly versatile tool for text manipulation in Linux. From simple substitutions to complex pattern matching and file modifications, sed can handle almost any task related to text processing. By mastering the commands and flags covered here, you can greatly enhance your text manipulation skills.

Don’t hesitate to experiment with these commands to solve your text processing needs, and let me know in the comments if you have any questions or need further clarification! 👨‍💻👩‍💻

Happy editing with sed! ✂️

How to Install BlackArch on Top of Arch Linux 🖤🐧

Eshan Roy (eshanized) — Thu, 05 Dec 2024 16:05:49 +0000

Are you an Arch Linux enthusiast looking to dive into the world of ethical hacking and pentesting? 🕵️‍♂️💻 BlackArch is here to level up your Arch system with over 2,800+ hacking tools. Here’s how you can install BlackArch on top of your existing Arch Linux system, step by step, with a sprinkle of emojis to make it fun! 🎉

🔧 Prerequisites

Make sure your Arch Linux system is updated and running smoothly. Run:

sudo pacman -Syu

Now, let’s get started! 🚀

Step 1: Add the BlackArch Repository 🗂️

BlackArch provides an easy way to add its repository to your system. Just execute the following commands:

curl -O https://blackarch.org/strap.sh

Verify the downloaded script to ensure its authenticity: 🛡️

echo "$(curl -fsSL https://blackarch.org/strap.sha256)  strap.sh" | sha256sum -c

If everything’s good, you’ll see strap.sh: OK. 👍

Step 2: Run the Installer 🛠️

Now, make the script executable and run it:

chmod +x strap.sh
sudo ./strap.sh

This will add the BlackArch repository and key to your system. 📥✨

Step 3: Sync the Package Database 📋

To make sure everything is updated:

sudo pacman -Syyu

This ensures you have the latest package listings from both Arch and BlackArch repositories. 🔄

Step 4: Install BlackArch Tools 🛡️

You can now install BlackArch tools in various ways:

Install Everything (Warning: It’s a lot! 😅):

   sudo pacman -S blackarch

Install Specific Groups (e.g., web, network):

   sudo pacman -S blackarch-web
   sudo pacman -S blackarch-network

Install a Single Tool:

   sudo pacman -S <tool-name>

Check out the list of tools here: BlackArch Tools 🔗

Step 5: Start Hacking (Ethically!) 🕶️

You’re now ready to explore the world of ethical hacking! Whether you’re testing networks, analyzing malware, or exploring cryptography, BlackArch has got you covered. 🎯

Bonus Tip 🌟

Not ready to install everything? You can run BlackArch tools in a container or virtual machine for testing. This keeps your main system clutter-free. 🛡️🖥️

🎉 Conclusion

With BlackArch on top of your Arch Linux, you now have a pentesting powerhouse! ⚡ Remember, with great power comes great responsibility—always use these tools ethically and responsibly. 🕊️

Happy hacking! 💻🐧✨

Got questions or tips? Drop them in the comments below! ⬇️

Forem: Eshan Roy (eshanized)

I Built an Automated SLM Fine-Tuning Engine with Python and Unsloth 🚀

🏗️ The Architecture

🧠 1. The Recommendation Engine

🔍 2. Dataset Intelligence

🪄 3. Self-Contained Notebooks

⚡ 4. Unsloth Integration

🌟 Supported Models

💻 Try it out

MultiGit: One repository. Infinite destinations

Why MultiGit?

Highlights

Quick Start

Core Features

Usage Cheatsheet

Configuration

Security Model

Architecture (High-Level)

How Sync Works

Interactive Setup & Conventional Commits

Daemon Mode

Examples

Testing & CI

Performance & Reliability

Roadmap

Get Started Today

Unlock clearer Rust dependency insight with dep-insight

Why I built it

What it does — and how

1. Analyze

2. Visualize

3. Integrate & Automate

When & how to use it

What it gets right

What’s still worth improving

Bottom line

9 Must-Know Python-Pandas Operations for Working with Data

Mastering Python Virtual Environments: A Complete Guide

📌 What is a Python Virtual Environment?

❓ Why Do We Need Virtual Environments?

⚙️ How Does a Virtual Environment Work?

1️⃣ Directory Structure

2️⃣ Activation Mechanism

3️⃣ Installing Packages

4️⃣ Deactivation

🔧 How to Set Up a Python Virtual Environment

1️⃣ Check Your Python Version

2️⃣ Create a Virtual Environment

Using venv (Recommended for Python 3.3+)

Using virtualenv (For older versions)

3️⃣ Activate the Virtual Environment

On macOS/Linux

On Windows (Command Prompt)

On Windows (PowerShell)

4️⃣ Install Dependencies

5️⃣ Deactivate the Virtual Environment

🔄 Managing Dependencies with requirements.txt

Save Installed Packages

Install from requirements.txt

🗑️ Deleting a Virtual Environment

🛠️ Advanced Virtual Environment Management

1️⃣ Using pyenv for Managing Python Versions

2️⃣ Using pipenv for Simplified Dependency Management

🚀 Best Practices for Virtual Environments

🎯 Conclusion

Why I Developed Snigdha OS?

1. A Tribute to Mubasshira Snigdha

2. Passion for Open Source and Innovation

3. Addressing Gaps in Existing Linux Distributions

4. Pushing My Technical Boundaries

5. Building a Legacy

Last Words

Install and use VirtualBox on Arch Linux & Snigdha OS

1. Install VirtualBox

Using pacman (Official Arch repository):

Install Kernel Headers:

Using the AUR (if you prefer the AUR version):

2. Add Your User to the vboxusers Group

3. Create a Virtual Machine (VM)

4. (Optional) Install Extension Pack

Using `venv` (Recommended for Python 3.3+)

Using `virtualenv` (For older versions)

🔄 Managing Dependencies with `requirements.txt`

Install from `requirements.txt`

1️⃣ Using `pyenv` for Managing Python Versions

2️⃣ Using `pipenv` for Simplified Dependency Management

Using `pacman` (Official Arch repository):

🚀 Introducing Preadme: Your Ultimate README Generator!

🎯 Common `sed` Commands & Flags Explained

1. Substitution Command (`s`)

2. Delete Command (`d`)

3. Print Command (`p`)

4. Insert Command (`i`)

5. Append Command (`a`)

6. Change Command (`c`)

8. Multiple Commands with `-e` Flag