Automate your web development environment setup in Termux!

Transform your Android device into a powerful development workstation!

Core-Termux is a powerful tool designed to streamline the setup of a modern web development environment directly on your Android device using the Termux app. Whether you're a beginner or an experienced developer, this project will help you get started quickly and efficiently.

Core-Termux stands out from other Termux setups because:

• Fully Automated: One command installation with no manual configuration needed
• Comprehensive: Includes everything you need for professional web development
• Optimized for Mobile: Specifically configured for the best Android experience
• Always Up-to-Date: Automatic updates ensure you have the latest features
• Professional Tools: Desktop-grade development environment on your phone
• Community Supported: Active development and community support

Core-Termux is perfect for:

• Web Developers: Frontend, backend, and full-stack developers
• Students: Learning programming on their mobile devices
• Professionals: Working on projects while on the go
• Enthusiasts: Exploring mobile development possibilities
• Educators: Teaching programming with a portable environment
• Open Source Contributors: Contributing to projects from anywhere

Showcasing the Powerlevel10k prompt (left) and NvChad editor (right).

These screenshots demonstrate the professional-grade environment you'll have after installation:

• Beautiful Shell: Powerlevel10k theme with Oh My Zsh provides a modern, informative prompt
• Powerful Editor: NvChad transforms Neovim into a full-featured IDE
• Custom Configuration: Pre-configured for optimal mobile development experience
• Professional Tools: All the tools you need for modern web development

For more visual examples of what Core-Termux provides:

• Zsh Plugins: See the enhanced shell experience with autosuggestions and syntax highlighting
• NvChad Features: Explore the file explorer, git integration, and code navigation
• Termux Customization: View the custom key bindings and optimized layout
• AI Tools: Experience the integrated AI assistants in action

Check out our YouTube Channel for video demonstrations!

• 🚀 Fully Automated Setup: Get your complete development environment ready with just one command - no manual configuration needed.
• 💻 Professional Code Editor: Pre-configured Neovim with the blazingly fast NvChad framework, featuring LSP support, autocompletion, file explorer, git integration, and more.
• 🎨 Enhanced Shell Experience: A beautiful and powerful shell powered by Oh My Zsh and Powerlevel10k, with 11 carefully selected Zsh plugins for maximum productivity.
• 📦 Comprehensive Package Collection: Includes programming languages (Node.js, Python, PHP, Perl), databases (MongoDB, PostgreSQL, MariaDB, SQLite), development tools (Git, GitHub CLI, Neovim), and utilities (curl, wget, jq, fzf, and more).
• 🤖 AI-Powered Tools: Integrated AI assistants like Gemini CLI and Qwen Code to boost your productivity with code generation, explanations, and more.
• 🔄 Auto-Updates: Keep your environment, tools, and configurations up to date automatically with every shell session.
• 🎯 Custom Termux Configuration: Pre-configured Termux keys for better navigation, custom cursor for visibility, and Meslo Nerd Font for proper icon display in Powerlevel10k and NvChad.
• 🔧 Custom Aliases: Includes useful aliases like ls enhanced with lsd for colorful directory listings and cat enhanced with bat for syntax-highlighted file viewing.

Core-Termux doesn't just set up your environment; it gives you a powerful, pre-configured code editor right out of the box with NvChad.

NvChad is a blazingly fast Neovim configuration that provides a stunning UI and a rich set of features for modern web development. Unlike traditional Neovim setups that require extensive manual configuration, NvChad comes with everything pre-configured and ready to use.

NvChad includes everything you need for professional development:

• Stunning UI: A beautiful and functional interface with custom themes and icons.
• Integrated File Explorer: Manage your files with NvimTree for easy navigation.
• Git Integration: Handle version control seamlessly within the editor with built-in git commands.
• Autocompletion & Snippets: Write code faster and with fewer errors using intelligent autocompletion.
• LSP Support: Built-in Language Server Protocol for intelligent code analysis, diagnostics, and suggestions.
• Terminal Integration: Embedded terminal for quick command execution without leaving the editor.
• Status Line: Custom status line with useful information about your file, git status, and more.
• Tab Management: Easy navigation between multiple files and buffers with intuitive keyboard shortcuts.
• Syntax Highlighting: Advanced syntax highlighting for numerous programming languages.
• Code Navigation: Easy navigation through your code with tags, symbols, and search functionality.
• And much more...

To get the most out of NvChad:

1. Explore the Interface: Familiarize yourself with the different components
2. Learn Keybindings: Master the keyboard shortcuts for efficient navigation
3. Customize Your Setup: Adjust the configuration to suit your workflow
4. Install Additional Plugins: Extend functionality with additional plugins
5. Watch Tutorials: Check out our Neovim Course for in-depth guidance

Want to see Core-Termux in action or master Neovim? Check out these resources:

• 📺 YouTube Channel: DevCoreX - Tutorials and demonstrations
• 🎓 Neovim Course: Neovim - NvChad - Learn to use NvChad effectively
• 📖 Documentation: This comprehensive README and related guides
• 💻 GitHub Repository: Core-Termux on GitHub

• 💬 GitHub Discussions: Join discussions about Core-Termux
• 🐙 GitHub Issues: Report bugs or request features
• 📚 Learning Materials: Additional tutorials and guides
• 🤝 Contributor Community: Join other developers improving Core-Termux

New to Core-Termux? Follow this learning path:

1. Installation: Start with the basic installation guide
2. Exploration: Familiarize yourself with the installed tools
3. Customization: Learn to customize your environment
4. Advanced Usage: Master advanced features and workflows
5. Contribution: Start contributing to the project

• Neovim Documentation: Learn about Neovim features and configuration
• Zsh Documentation: Master Zsh shell and its powerful features
• Termux Documentation: Understand Termux capabilities and limitations
• Web Development: Learn modern web development practices

Before installing Core-Termux, ensure you have:

• Minimum 8GB of available storage (recommended 10GB+ for full functionality)
• Termux App installed from GitHub (recommended)
• Stable Internet Connection (required for downloading ~1-2GB of packages)
• Git installed (pkg install git)
• Battery Optimization Disabled for Termux
• Termux Storage Permission granted (termux-setup-storage)

Follow these steps to prepare your device:

1. Free Up Space:

   • Delete unnecessary files or apps
   • Ensure you have 10GB+ free storage
   • Check with: df -h in Termux

2. Install Termux:

   • Download from GitHub
   • Avoid Play Store version if possible
   • Grant all required permissions

3. Disable Battery Optimization:

   • Go to Android Settings > Apps > Termux
   • Select "Battery" or "Battery Optimization"
   • Choose "Don't optimize" or "No restriction"

4. Grant Storage Permission:

   • Open Termux
   • Run: termux-setup-storage
   • Follow the prompts to grant access

5. Update Termux:

   • Run: pkg update && pkg upgrade
   • This ensures you have the latest packages

6. Install Git:

   • Run: pkg install git
   • Verify with: git --version

Get started with these simple commands:

1. Clone the Repository:

   git clone https://github.com/DevCoreXOfficial/core-termux.git
   cd core-termux

2. Run the Setup Script:

   bash setup.sh

3. Restart Termux: After installation completes, restart Termux to apply all changes.

The installation process performs the following steps:

1. System Preparation:

   • Creates installation directory (~/.core-termux)
   • Copies configuration files
   • Updates and upgrades Termux packages

2. Package Installation:

   • Installs Termux packages (languages, tools, databases)
   • Installs global Node.js modules
   • Configures additional repositories

3. Shell Configuration:

   • Installs Oh My Zsh with Powerlevel10k
   • Configures 11 Zsh plugins
   • Sets up custom aliases and key bindings

4. Termux Customization:

   • Configures custom extra keys
   • Sets custom cursor color
   • Installs Meslo Nerd Font

5. Editor Setup:

   • Installs NvChad with Neovim
   • Configures all plugins and settings

6. Final Configuration:

   • Sets up automatic updates
   • Configures environment variables
   • Prepares for first use

During installation, you'll see:

1. Package Updates: Termux repositories being updated
2. Package Installation: All required packages being installed
3. Node Modules: Global npm packages being installed
4. Zsh Setup: Oh My Zsh and plugins being configured
5. Termux Configuration: Custom keys, cursor, and font
6. NvChad Installation: Neovim configuration being set up
7. Final Setup: Aliases and update system being configured

After successful installation:

1. Restart Termux: Close and reopen the app
2. Verify Installation: Check that all tools are working
3. Test Editor: Open Neovim to verify NvChad
4. Test Shell: Verify Zsh plugins are working
5. Explore Features: Familiarize yourself with the environment

# Check Zsh version
zsh --version

# Check Neovim version
nvim --version

# Check Node.js version
node --version

# Check installed packages
pkg list-installed | grep -E '(git|python|nodejs|neovim)'

# Check global npm modules
npm list -g --depth=0

Core-Termux includes a robust update system that ensures your environment stays current:

• The system automatically checks for updates and applies them when you start a new shell session.
• This ensures you always have the latest features, bug fixes, and security updates.
• Updates run silently in the background without interrupting your workflow.

You can also manually trigger updates by executing:

bash update.sh

This is useful when you want to:

• Force an immediate update
• Verify the update process
• Troubleshoot update issues
• Update after making changes to the repository

The update process consists of two main scripts working together:

1. update.sh: Synchronizes your local files with the latest version from the repository.

   • Pulls the latest changes from GitHub
   • Compares local and remote versions
   • Identifies what needs to be updated

2. bootstrap.sh: Handles the actual update of all tools, packages, and configurations.

   • Updates Core-Termux scripts
   • Refreshes configuration files
   • Updates NvChad and plugins
   • Refreshes Zsh plugins
   • Ensures all dependencies are current

The update system keeps the following components current:

• Core-Termux scripts: Main setup and update scripts
• Configuration files: All configuration files and settings
• NvChad editor: Neovim configuration and plugins
• Zsh plugins: All 11 Zsh plugins and their configurations
• Package dependencies: All installed Termux packages
• Node.js modules: All global Node.js modules
• Termux configuration: Keys, cursor, and font settings
• Environment variables: Paths and aliases

• Automatic updates: Run every time you start a new shell session
• Manual updates: Can be triggered anytime with bash update.sh
• Repository sync: Always pulls the latest version from GitHub
• Change detection: Only updates what has changed

Regular updates provide:

• New Features: Access to the latest functionality
• Bug Fixes: Resolved issues and improved stability
• Security Updates: Protection against vulnerabilities
• Performance Improvements: Optimized code and configurations
• Compatibility: Support for new Android and Termux versions

If updates aren't working:

1. Check Internet: Ensure you have a stable connection
2. Verify Git: Make sure git is working properly
3. Manual Update: Try running bash update.sh manually
4. Check Logs: Review the update output for errors
5. Reinstall: As a last resort, reinstall Core-Termux

If you need to temporarily disable automatic updates:

1. Edit your .zshrc file
2. Comment out or remove the update line
3. Save and restart your shell

# Comment this line to disable auto-updates
# source ${core}/update.sh > >(tee /dev/tty) 2>&1

core-termux/
├── assets/             # Fonts and images (Meslo Nerd Font, screenshots)
├── bootstrap.sh        # Called by update.sh, handles the update of all tools
├── config              # Color variables and settings for scripts
├── setup.sh            # Main setup script - installs everything
├── update.sh           # Syncs files and runs bootstrap.sh for updates
├── LICENSE             # MIT License file
└── README.md           # This documentation file

• setup.sh: The main installation script that sets up your entire development environment.
• update.sh: Handles updates by syncing with the latest repository version.
• bootstrap.sh: Called by update.sh to perform the actual update operations.
• config: Contains color variables and settings used by the scripts.
• assets/: Contains the Meslo Nerd Font and screenshot images.

Core-Termux includes several custom configurations to enhance your Termux experience:

We've optimized Termux for the best development experience:

• Custom Extra Keys: Optimized key layout for better navigation and productivity:

  [['ESC','</>','-','HOME',{key: 'UP', display: '▲'},'END','PGUP'],
  ['TAB','CTRL','ALT',{key: 'LEFT', display: '◀'},{key: 'DOWN', display: '▼'},{key: 'RIGHT', display: '▶'},'PGDN']]
  

• Custom Cursor: Green cursor for better visibility (cursor=#00FF00).
• Meslo Nerd Font: Installed for proper icon display in Powerlevel10k and NvChad.

Enhanced commands for better productivity:

• ls: Enhanced with lsd for colorful and detailed directory listings with icons.
• cat: Enhanced with bat (Dracula theme) for syntax-highlighted file viewing.

The .zshrc file is automatically configured with:

• All 11 Zsh plugins loaded and ready
• Custom key bindings for history search
• Fzf-tab configuration for enhanced completion
• Automatic update system integration
• Path to Core-Termux for easy access

• Improved Productivity: Optimized layout and shortcuts save time
• Better Visibility: Custom cursor and fonts enhance readability
• Enhanced Commands: Aliases provide more informative output
• Consistent Experience: Standardized configuration across devices

We welcome contributions to Core-Termux! Here's how you can help improve the project:

1. Fork the Repository: Create your own fork of the project on GitHub.
2. Create a Branch: Work on a new feature or bug fix in a separate branch.

   git checkout -b feature/your-feature-name

3. Make Changes: Implement your improvements with clear, well-documented code.
4. Test Thoroughly: Ensure your changes work correctly in different scenarios.
5. Commit Changes: Use descriptive commit messages.

   git commit -m "Add feature: your feature description"

6. Push to Your Fork: Push your changes to your GitHub fork.

   git push origin feature/your-feature-name

7. Submit a Pull Request: Share your contributions with the community.

Here are some ways you can contribute:

• New Features:

  • Add support for new programming languages or tools
  • Implement additional Termux customizations
  • Add new Zsh plugins or themes
  • Enhance the update and installation process

• Improvements:

  • Improve existing configurations and optimizations
  • Enhance performance and reduce installation time
  • Add better error handling and user feedback
  • Improve compatibility with different Android versions

• Documentation:

  • Enhance documentation and examples
  • Add more detailed explanations and tutorials
  • Improve the README with better organization
  • Create video tutorials or screenshots

• Bug Fixes:

  • Fix bugs and improve stability
  • Address compatibility issues
  • Improve error messages and debugging
  • Optimize resource usage

Please be respectful and follow best practices when contributing:

• Be Respectful: Treat all contributors with respect and kindness.
• Follow Standards: Adhere to existing code style and conventions.
• Document Changes: Provide clear documentation for new features.
• Test Thoroughly: Ensure your changes don't break existing functionality.
• Communicate Clearly: Provide clear descriptions in pull requests and issues.

Core-Termux is open-source software licensed under the MIT License:

• Free to Use: You can use, modify, and distribute this software freely.
• Attribution: While not required, attribution to the original project is appreciated.
• No Warranty: The software is provided "as is" without any warranty.
• No Liability: The authors are not liable for any damages.

Under the MIT License, you are free to:

• Use: Use the software for any purpose, commercial or personal
• Modify: Change the software to suit your needs
• Distribute: Share the software with others
• Sublicense: Include the software in your own projects

• Include License: Keep the original license file with any distribution
• Include Copyright: Maintain the original copyright notices
• State Changes: Document any significant changes you make

• Claim Ownership: You cannot claim you wrote the original software
• Hold Liable: You cannot hold the authors liable for any issues

For full license details, see the LICENSE file.

If you use Core-Termux in your projects, we appreciate (but don't require) attribution:

This project uses Core-Termux (https://github.com/DevCoreXOfficial/core-termux)

To remove Core-Termux:

# Remove Core-Termux directory
rm -rf ~/.core-termux

# Remove Zsh plugins
rm -rf ~/.zsh-plugins

# Remove NvChad
rm -rf ~/.config/nvim
rm -rf ~/.local/state/nvim
rm -rf ~/.local/share/nvim

# Reset Termux configuration (optional)
rm -rf ~/.termux

Thank you for using Core-Termux! Happy coding! 🚀

Questions? Issues? Join our community for support!