DEV Community: Ranganath Reddy

From Dust to Dev Tool: (Part 2)

Ranganath Reddy — Sat, 17 Jan 2026 04:11:54 +0000

Linux Distro in old tablet

In Part 1, I talked about curiosity and how Termux turned an old Android tablet into something usable again. If you missed that post here is the link Part-1

But Termux was never the end goal.

What I really wanted was this:

A real Linux system. The kind that behaves like a server, not a phone.

That’s where Debian inside Termux comes in.

🧠 Why I Needed Debian (Not Just Termux)

Termux is powerful, but it still speaks Android first.

I wanted:

apt, not pkg

A standard Linux filesystem (/etc, /usr, /bin)

Tools behaving exactly like cloud servers

Muscle memory that transfers to real infra

Debian gives you that — clean, boring, reliable.

And boring Linux is the best Linux.

🧩 How Debian Runs Without Root (The Magic)

This setup does not:

Root the device ❌
Replace Android ❌
Break system security ❌

Instead, it uses PRoot.

Think of it like this:

🟢 Termux = Host / Interface
🐧 Debian = Guest / Workspace

PRoot creates a fake root filesystem where programs believe they’re running on real Linux.

No kernel hacks.
No risk.

Just clean isolation.

🚀 Installing Debian (One-Time, Persistent Setup)

From inside Termux:

pkg install proot-distro
proot-distro install debian
proot-distro login debian

That’s the moment it clicks.

You’re not emulating Linux.
You’re living inside it.

To exit:

exit

Debian doesn’t disappear.
It waits.

💾 Persistence: Why This Feels Like a Real Machine

This Debian setup:

✅ Survives reboots
✅ Survives closing Termux
✅ Lives inside internal storage
❌ Disappears only if Termux is uninstalled

That persistence changes everything.

You stop “testing”.
You start using it daily.

🧬 Architecture Reality Check (32-bit Truth)

This tablet runs a 32-bit userspace (armhf / armv7l).

That single fact explains a lot.

What it means in practice:

❌ 64-bit binaries won’t run
❌ Many modern prebuilt tools silently fail
❌ Neovim + LazyVim = nope

Tool Choices Under Constraints

Heavy tools were not an option.

So I leaned into:

CLI-first workflow

Lightweight editors

Zero background bloat

Why I Chose Micro 📝

Micro turned out to be perfect:

Fast even on 2GB RAM
Works on 32-bit ARM
Modern features without heaviness
- Mouse support, plugins, shell commands inside editor

🖥️ How Debian Feels on a Tablet

Honestly?

Like a tiny server in my hands.

No distractions.
No notifications.
Just:

The shell

The filesystem

My thoughts

This environment forced me to:

Read error messages properly

Understand architecture limits

Install only what I truly need

Learn Linux instead of decorating it

*️⃣ Final Take

This is entire process of making Android tablet into Linux helped me to learn lot about Linux and raised interest in System programming will continue to explore more on Low-Level programming soon ~♾️

📦 Full Setup & Configs

I’ve documented everything — Termux + Debian setup, shell configs, editor choice, fonts, fixes — in my GitHub repo:

👉 Termux-config

From Dust to Dev Tool: Linux on an Old Android Tablet (Part 1)

Ranganath Reddy — Thu, 15 Jan 2026 13:53:31 +0000

Linux Inside a Tablet: How Curiosity Turned an Old Android into a Dev Machine

I didn’t start this because I wanted a new setup.

I started this because I had an old Android tablet lying around and a simple question in my head:

“Can I actually use Linux properly on this?”

The device was nothing special —
2GB RAM, 32GB storage, slow, forgotten, and mostly useless for modern apps.

Most people would either sell it or let it collect dust.

I decided to stress my curiosity instead of the hardware.

Why Even Try This?

Today, learning Linux usually looks like:

Powerful laptops

Heavy IDEs

Desktop environments doing half the thinking

But real systems don’t work that way.

So I asked myself:

If Linux can run servers and routers, why can’t I learn it on a low-end tablet?

That thought led me to Termux.

Discovering Termux (The Entry Point)

Termux is not an emulator.
It’s not a VM.

It’s a real Linux environment running directly on Android, without root.

Once installed, you get:

A terminal

A package manager

Compilers, interpreters, shells

Access to Android APIs

Suddenly, this “weak tablet” felt like a small Linux box.

⚠️ Important note
Termux must be installed from F-Droid, not the Play Store.
The Play Store version is outdated and broken.

If you want to replicate this setup or explore it step by step, you can find everything here please Star it ⭐:
Termux-config

First Reality Check: Know Your System

Before installing random tools, I wanted to know what I was actually running.

So I asked the system:

uname -m
dpkg --print-architecture
uptime

What I discovered

Even though the hardware supports 64-bit,
Android runs a 32-bit userspace on this device.

Architecture came back as:

armv7l

armhf

This single detail explained everything that came later.

Why This Changed My Approach

Because now I knew:

❌ 64-bit binaries won’t work

✅ Only 32-bit tools are safe

✅ Lightweight software is mandatory

Instead of fighting errors, I started working with the system, not against it.

That mindset carried the entire project forward.

Setting Up Termux (The Basics)

First things first:

pkg update && pkg upgrade
termux-setup-storage

Storage access matters more than you think.

Then the essentials:

pkg install git clang make python neofetch vim htop wget unzip tar

No bloat.
No GUI.
Just tools you’d expect on a minimal Linux machine.

Understanding the Shell (Small but Important)

I checked which shell I was using:

echo $0

Depending on the version, it could be:
bash
zsh
or sh

Most scripts still work everywhere if you use a proper shebang:

!/bin/bash

Details like this save hours later.

When Linux Starts Talking to Android

After installing:

pkg install termux-api

Things got interesting.

Now Linux scripts could interact with Android hardware.

Examples:

termux-tts-speak "Hello from Linux"
termux-battery-status
termux-clipboard-set "Copied from Termux"

This is where Termux stopped feeling like a terminal app
and started feeling like a bridge between Linux and Android.

The Mental Model That Made Everything Clear

I began thinking in two layers:

🌍 Termux — The Outer World

Talks to Android

Handles UI, fonts, storage, APIs

Uses pkg

🐧 Linux — The Inner World

Real Linux behavior

Real tools

Real learning

Termux became the interface layer.

Why This Matters

This setup forced me to:

Read error messages

Respect architecture limits

Choose tools carefully

Understand Linux instead of memorizing commands

Low-end hardware didn’t slow learning.

It accelerated understanding.

💓 What’s Next?

This is only Part 1.

In Part 2, I’ll cover:

Running a full Linux distro inside Termux,Setting oh-my-posh,using Micro ide

How it stays persistent

Why it feels like carrying a tiny server in my hands

Stay tuned for Part 2~♾️.