If you are a developer building tools for Android, especially for Termux, you probably know how difficult it can be to distribute your software to other Termux users.

You can publish your project on GitHub, provide installation instructions, or ask users to build everything manually.

But what if you could distribute your tools through a community-driven package manager?

That is what "termux-app-store" (https://github.com/djunekz/termux-app-store) is designed to do.

Termux-app-store (TAS) is an local-first, source-based TUI and CLI package manager for Termux on Android. It allows users to discover, build, and install community-maintained tools through a centralized package repository.

In this tutorial, you will learn how to submit your own package to termux-app-store.

What Is termux-app-store?

Termux-App-Store is an independent, community-driven package distribution project for Termux.

Its goal is to make it easier for developers to distribute their tools and for users to discover and install them.

Some of its key features include:

  • Source-based packaging: Distribute software using package build scripts.
  • Binary distribution: Support prebuilt package installation.
  • SHA256 verification: Verify downloaded source archives and binary artifacts.
  • Offline-first approach: Use locally available package metadata and cached binaries where supported.
  • TUI and CLI: Browse and manage packages through terminal interfaces.
  • No root required: Designed for the normal Termux environment.

Think of it as an additional community-driven distribution channel for Termux tools.

It does not replace the official Termux repositories.

Repository: https://github.com/djunekz/termux-app-store

  1. Prepare Your Development Environment

Before submitting a package, make sure you have:

  • Termux installed.
  • Git installed.
  • Python 3 installed.
  • A GitHub account.
  • A software project that you have permission to distribute.

Install the basic tools:

pkg update && pkg upgrade
pkg install git python nano

You should also have access to your software's upstream source repository.

For this example, we will use a hypothetical package called "example".

  1. Fork the Termux-App-Store Repository

First, open the official repository:

https://github.com/djunekz/termux-app-store

Click Fork to create your own copy.

Then clone your fork:

git clone --depth 1 --single-branch --branch master \
https://github.com/YOUR_USERNAME/termux-app-store.git

cd termux-app-store

Replace "YOUR_USERNAME" with your GitHub username.

Create a separate branch for your package:

git checkout -b example

Using a dedicated branch makes it easier to submit and maintain your changes.

  1. Create Your Package

Termux-a
 pp-store organizes packages inside the "packages/" directory.

The general structure looks like this:

termux-app-store/
└── packages/
└── example/
└── build.sh

There are several ways to generate the package build script.

Option A: Use the interactive package scaffold

The repository provides "pkg-scaffold.py" to help generate package metadata and a build script.

Run:

python3 pkg-scaffold.py example

You can also provide your upstream GitHub repository:

python3 pkg-scaffold.py \
--from https://github.com/YOUR_USERNAME/YOUR_PROJECT

The scaffold can help detect the project type, retrieve available metadata, calculate the source SHA256, and generate an initial build script.

Review everything it generates before submitting.

Option B: Use the built-in template

You can generate a template with:

./termux-build template

Or use the template directly from the repository:

mkdir -p packages/example
nano packages/example/build.sh

  1. Configure Your build.sh

Every package needs a "build.sh" containing its metadata.

The required metadata fields include:

TERMUX_PKG_HOMEPAGE=
TERMUX_PKG_DESCRIPTION=""
TERMUX_PKG_LICENSE=""
TERMUX_PKG_MAINTAINER=""
TERMUX_PKG_VERSION=
TERMUX_PKG_SRCURL=
TERMUX_PKG_SHA256=

Here is an illustrative example:

TERMUX_PKG_HOMEPAGE="https://github.com/YOUR_USERNAME/example"

TERMUX_PKG_DESCRIPTION="An example command-line utility for Termux"

TERMUX_PKG_LICENSE="MIT"

TERMUX_PKG_MAINTAINER="@YOUR_USERNAME"

TERMUX_PKG_VERSION="1.0.0"

TERMUX_PKG_SRCURL="https://github.com/YOUR_USERNAME/example/archive/refs/tags/v${TERMUX_PKG_VERSION}.tar.gz"

TERMUX_PKG_SHA256="YOUR_REAL_SOURCE_SHA256"

Replace all example values with the actual information for your project.

Important: Never submit a fake SHA256 value. The checksum must correspond to the exact source archive referenced by "TERMUX_PKG_SRCURL".

You can calculate the checksum using:

sha256sum source.tar.gz

If your project requires a custom installation procedure, review the generated build method and implement the appropriate installation step. Do not leave a placeholder installation function in a production package.

  1. Validate Your Package

This is an important part of the submission process.

Before opening a Pull Request, use the built-in "termux-build" tool.

Run:

./termux-build lint packages/example

Check the development environment:

./termux-build doctor

Then check whether your package is ready for a Pull Request:

./termux-build check-pr example

These commands help identify common packaging problems before maintainers review your contribution.

You should resolve reported errors before submitting.

Note that "termux-build" is a validation and review helper. It does not automatically publish packages or upload files to GitHub.

  1. Commit Your Package

Once validation is complete, commit your package:

git add packages/example

git commit -m "New package: example"

Push your branch:

git push origin example

Your branch will now be available in your GitHub fork.

  1. Submit a Pull Request

Open your fork on GitHub.

You should see an option to create a Pull Request.

Select the original repository as the destination:

Base repository:
djunekz/termux-app-store

Base branch:
master

Head repository:
YOUR_USERNAME/termux-app-store

Compare branch:
example

In your Pull Request description, explain:

  • What your package does.
  • Why it is useful for Termux users.
  • Where its original source code is hosted.
  • Which license it uses.
  • How the package is built and tested.

Keep the description clear and technically accurate.

  1. Wait for Package Review

Submitting a Pull Request does not mean your package is automatically accepted.

The maintainers may inspect:

  • Package metadata.
  • Upstream source authenticity.
  • Source archive integrity.
  • Build instructions.
  • Dependencies.
  • Installation behavior.
  • Compatibility with Termux.
  • Security and licensing considerations.

If changes are requested, update your package and push the changes to the same branch.

Your Pull Request will update automatically.

Once the package has been reviewed and merged, it can proceed through the repository's package indexing and distribution workflow.

  1. What Happens After Your Package Is Accepted?

Your contribution becomes part of the Termux App Store package ecosystem.

Depending on the package and available build infrastructure, users can access the package through the repository's supported installation methods.

The project supports both source-based and binary distribution workflows.

Binary installation uses SHA256 verification to check artifact integrity, while source-based installation follows the package build instructions.

Users can then discover and manage packages through the Termux App Store TUI and CLI.

For example:

termux-app-store

Or use the CLI:

termux-app-store list
termux-app-store show example
termux-app-store install example

The exact availability of a package depends on its successful review, indexing, and distribution status.

  1. Package Maintenance Is Part of Open Source

Publishing a package is only the beginning.

As a package maintainer, you should:

  • Keep track of upstream releases.
  • Update package versions when appropriate.
  • Verify source checksums.
  • Test installation after important updates.
  • Fix compatibility issues.
  • Respond to review feedback.
  • Keep your package metadata accurate.

A package repository is only as reliable as the people maintaining its packages.

That is why community participation matters.

Contribute to Termux App Store

You do not need to create a large project to contribute.

A small command-line utility, developer tool, automation script, or useful open-source application can also be a valuable addition.

If you maintain a project for Termux users, consider submitting it.

Official resources:

Final Thoughts

I started Termux App Store with a simple idea: developers should have a better way to distribute their tools to the Termux community.

Software distribution should be transparent. Users should be able to understand where their packages come from, how they are built, and how their integrity is verified.

Termux App Store is an independent, community-driven effort to make that possible.

Whether you are a developer building your first CLI utility or an experienced maintainer distributing multiple projects, you are welcome to contribute.

Local first. Control over convenience. Transparency over magic.

Project: "Djunekz / Termux App Store" (https://github.com/djunekz/termux-app-store)

Built and maintained by Djunekz — Independent Software Developer.