If you use Termux on Android, you probably know the workflow:
pkg update
pkg install
It works well for many use cases.
But what happens when you want more control over where packages come from, how they are built, how they are installed, or how you manage source-based packages?
That was one of the reasons I started building Termux App Store (TAS).
«Termux App Store is an offline-first, source-based TUI and CLI package manager built natively for Termux.»
The goal is simple:
Local first. Control over convenience. Transparency over magic.
What is Termux App Store?
Termux App Store is an open-source package management tool designed specifically for the Termux environment on Android.
It provides both:
- A terminal user interface (TUI)
- A command-line interface (CLI)
- Source-based package builds
- Package discovery
- Package information
- Installation and upgrades
- Local package caching
- Package verification
- Build tooling
The project is available on GitHub:
https://github.com/djunekz/termux-app-store
It is also distributed through PyPI:
https://pypi.org/project/termux-app-store/
Why another package manager for Termux?
Termux already has a powerful package management ecosystem.
TAS isn't intended to replace it.
Instead, the project explores another approach to package management:
What if installing a Termux package could also be transparent, reproducible, and source-oriented?
For example, a developer may want to:
- Discover a package.
- Inspect its information.
- Review its source.
- Build it.
- Install it locally.
- Upgrade it later.
- Keep useful artifacts available offline.
That workflow becomes particularly useful when working with development tools, personal utilities, experimental packages, and community projects.
TUI and CLI in the same tool
One of the main design decisions behind TAS was supporting both interactive and scripted workflows.
TUI
Run:
termux-app-store
The TUI provides an interactive interface for browsing and managing packages.
It is designed to work comfortably in a terminal, including touchscreen-based Termux environments.
CLI
For users who prefer commands:
termux-app-store list
Show package information:
termux-app-store show
Install a package:
termux-app-store install
Update package metadata:
termux-app-store update
Upgrade packages:
termux-app-store upgrade
Check the installed version:
termux-app-store version
This makes TAS useful for both interactive users and automation.
Source-based package management
One of the core ideas behind Termux App Store is source-based package building.
Instead of treating a package as an opaque artifact, the project provides tooling around the process of obtaining source code, building packages, checking build definitions, and producing installable output.
This is useful for developers who want to understand what happens between:
Source Code
↓
Build Definition
↓
Build
↓
Package
↓
Verification
↓
Installation
The project also includes development tooling for package builders.
Building packages for Termux
TAS includes a package-building workflow intended for developers working with Termux packages.
For example:
termux-build init
The builder can help with common development tasks such as:
- initializing package projects
- checking package definitions
- validating build scripts
- diagnosing the environment
- reviewing pull-request-related package changes
- generating templates
- explaining build configuration
The goal is to make creating a Termux package less intimidating for developers who are new to the Termux packaging ecosystem.
Offline-first package management
Another important idea behind TAS is offline-first operation.
Mobile environments are not always reliable.
You may have:
- limited internet access
- expensive mobile data
- unstable connections
- packages that you want to keep locally
- a development environment that should remain usable without constantly downloading everything again
For that reason, local caching and local package availability are important parts of the project.
The broader philosophy is:
«Don't assume the network will always be available.»
A package manager on a mobile device should be able to make sensible use of what is already available locally.
Package verification
Software distribution also raises an important question:
How do you know that the package you downloaded is the package you expected?
TAS includes checksum-based verification mechanisms for supported package artifacts.
For example, SHA-256 hashes can be used to verify downloaded files:
Package
↓
SHA-256
↓
Expected hash
↓
Match?
├── Yes → Continue
└── No → Reject
This is a small but important part of making software distribution more transparent.
Why build from source?
Source builds aren't necessary for every user.
But they are valuable when you want more control.
Building from source can help you:
- inspect build instructions
- understand dependencies
- reproduce a package
- modify software
- experiment with different configurations
- contribute fixes
- learn how Termux packages are structured
For developers learning Android terminal environments, package building can also be a practical way to learn Linux packaging concepts.
Designed for Termux
Termux is unusual because it brings a Linux-like command-line environment to Android without requiring a traditional desktop Linux installation.
That makes it useful for:
- Python development
- shell scripting
- Git
- automation
- programming
- server administration
- cybersecurity education
- development tooling
- local automation
- lightweight Linux workflows
TAS is designed specifically around that environment rather than trying to be a generic Android application store.
Example workflow
A typical workflow might look like this:
Update package information
termux-app-store update
Browse available packages
termux-app-store list
Inspect a package
termux-app-store show example
Install it
termux-app-store install example
Upgrade installed packages
termux-app-store upgrade
The same workflow can be approached through the interactive TUI:
termux-app-store
This makes it possible to choose between a traditional CLI workflow and an interactive terminal interface.
Who is Termux App Store for?
TAS may be interesting if you are:
A Termux user
You want a more visual terminal package workflow without leaving the command line.
A developer
You want to build and test packages for Termux.
A Linux enthusiast
You enjoy experimenting with Linux-style environments on Android.
A package maintainer
You want tooling around package creation, validation, and distribution.
An automation enthusiast
You prefer command-line tools that can be incorporated into scripts and workflows.
What makes it different?
The project isn't trying to win by having the largest package catalog.
The focus is different.
TAS emphasizes:
Source
Know where software comes from.
Transparency
Make package operations understandable.
Local-first workflows
Use locally available resources whenever possible.
Developer tooling
Make package creation and maintenance easier.
CLI + TUI
Give users both automation and interactive interfaces.
Open source
The implementation is available for inspection and contribution.
Installing Termux App Store
The Python package is available on PyPI.
pip install termux-app-store
After installation:
termux-app-store
You can also explore the complete source code, documentation, workflows, and development history on GitHub.
Open source and community
Termux App Store is an independent open-source project.
The intention is not to create another opaque layer between developers and their software.
Instead, the project follows a simple principle:
«Local first. Control over convenience. Transparency over magic.»
Contributions, testing, bug reports, package suggestions, and improvements are welcome.
If you work with Termux and have an idea for improving the package ecosystem, the repository is the best place to start.
Try Termux App Store
GitHub
https://github.com/djunekz/termux-app-store
PyPI
https://pypi.org/project/termux-app-store/
Install
pip install termux-app-store
Then:
termux-app-store
If you're already using Termux on Android, give it a try and see whether a source-oriented, offline-first package workflow fits the way you work.
Final thoughts
Termux has evolved into much more than a terminal emulator.
For many developers, an Android phone can now function as a surprisingly capable development environment.
That makes package management increasingly important.
Termux App Store is an experiment in building that experience around source transparency, local-first workflows, developer tooling, and a combination of CLI and TUI interfaces.
It's still an evolving open-source project.
And that's exactly the point.
Build it. Inspect it. Improve it.
Top comments (0)