u/Specialist-One-3465

​

Hi everyone I’m currently learning Linux administration and I wanted to build a small home lab instead of only practicing commands theoretically. My current setup is: Android Phone → Termux → SSH → Arch Linux Laptop The idea is to use my Arch Linux laptop as a small practice server and manage it remotely from Termux.

Current workflow

Android Phone

│

Termux

│

SSH

↓

Arch Linux Laptop

│

└── Linux Admin Practice Server

I have already:

- Installed/configured OpenSSH on Arch Linux

- Started the "sshd" service

- Confirmed that SSH is listening on port 22

- Checked the laptop's local IP

- Planned to connect from Termux using SSH

My goal is to use this environment to practice real Linux administration concepts such as:

- Users & groups

- Permissions

- SSH administration

- Processes & services

- systemd

- Networking

- Package management

- Logs

- Disk/storage management

- Cron/systemd timers

- Firewall

- Server hardening

- Troubleshooting

I know this isn't the same as managing a production server, but I think it can give me a practical environment to learn and experiment safely.

My question to experienced Linux admins:

Is this a good approach for learning Linux administration? What important topics or real-world tasks would you recommend adding to this home lab?

Any advice on what I should practice next would be really helpful.

I’m curious about how developers are using AI in real-world projects.

For example, do you follow a workflow like:

Idea → choose the tech stack → design the project structure → use AI for coding → test → GitHub → release

Or are you using AI agents / IDE integrations where you give a high-level prompt and the AI handles most of the work — writing code, modifying files, running tests, fixing errors, etc

I’m especially interested in hearing from developers who are actively building and maintaining real projects.

What does your AI-assisted development workflow look like?

Hi everyone,

I'm a student building an open-source terminal engine in C.

Could senior developers please review my project and share feedback on the code, project structure, and README

Repository: BackendDeveloperHub/bdh-terminal-engine

Any suggestions are appreciated. Thank you!

Instead of launching into a full desktop after a minimal Arch Linux install, what if you were dropped into a preconfigured TTY development environment?

Imagine:

-Ranger for file management

- Nano (or your preferred editor)

- Integrated shell

- Tmux workspaces

- Quick PostgreSQL access

- Terminal browser

- Session recorder

The goal isn't to replace VS Code or other GUI IDEs.

The goal is to provide a fast, lightweight, keyboard-first development environment that works immediately after boot, especially for:

- Arch Linux minimal users

- SSH/remote development

- Older hardware

- Developers who prefer terminal workflows

Would you use something like this?

If not, what features would make a TTY-first development environment genuinely useful

I'm thinking about creating my own Linux-based OS with a custom shell, custom IDE, and my own programming language instead of the usual Bash experience.

Has anyone here built something similar? Any advice or things I should know before starting?

Hey everyone! 👋

​A while ago, I started working on BDH Linux IDE (bdh-linux-ide), a lightweight, terminal-only environment using Tmux, Ranger, and Nano for backend developers. I wanted a zero-distraction workflow.

​Today, I’m releasing a massive update (v1.0.1) that adds some really cool workflows to the TTY environment. Instead of bloated GUI apps, I built custom CLI commands to handle everything:

​🔥 The 3 Major Updates:

​1. bdh-browser (Minimal Wayland Kiosk Browser)

Working in TTY is great, but sometimes you need to read docs or test an API.

​By running bdh-browser <URL>, it launches a minimal Wayland compositor (cage) inside the TTY.

​It uses wlr-randr to detect my external HDMI monitor and opens Firefox in full-screen kiosk mode, while keeping my terminal IDE untouched on my laptop screen. When I close it, it returns cleanly to the TTY.

​2. bdh-record (TTY to Smartphone GIF Exporter)

I wanted to share my terminal workflow from my laptop to my phone instantly without cables.

​Running bdh-record starts recording the terminal using asciinema.

​Once you type exit, it automatically uses agg to convert the .cast file into a high-quality GIF.

​It then instantly spins up a local Python HTTP server and prints the IP address in the terminal. I just type that IP on my phone's browser, download the GIF, and hit Ctrl+C to close the server. Magic! ✨

​3. bdh-db (Instant PostgreSQL Environment)

Since this is an IDE for backend devs (I use FastAPI), setting up a DB shouldn't be a hassle.

​The installer now automatically initializes (initdb) and enables the PostgreSQL service locally.

​Typing bdh-db drops you straight into the postgres=# shell. No setup required.

🛠️ How to install it?

It's available for Arch Linux. You can clone it and run the global installer:

```bash

git clone https://github.com/BackendDeveloperHub/bdh-linux-ide.git

cd bdh-linux-ide

chmod +x install.sh

sudo ./install.sh

```

I’m currently a BCA student learning low-level stuff and backend architecture, and building this tool has taught me so much about DRM, Wayland, and bash scripting.

I would love to hear your thoughts, feedback, or any crazy terminal ideas I should add next! ❤️

GitHub:https://github.com/BackendDeveloperHub/bdh-linux-ide

Hey r/archlinux,

I built a very lightweight, terminal-based IDE wrapper using Tmux, Ranger, and Nano.

Why? Because modern IDEs have too much AI and auto-complete. I wanted a strict environment that forces beginners (and myself) to type every single line of code and learn the hard way. It's great for building muscle memory!

I just published it to the AUR today.

Install: yay -S bdh-linux-ide

Run: bdh-ide (and bdh-ide-kill to close).

🔗 GitHub: https://github.com/BackendDeveloperHub/bdh-linux-ide

🔗 AUR: https://aur.archlinux.org/packages/bdh-linux-ide

Would love to hear your feedback!