diff --git a/deepseek-coder-android-termux.md b/deepseek-coder-android-termux.md
new file mode 100644
index 0000000..9cf8a66
--- /dev/null
+++ b/deepseek-coder-android-termux.md
@@ -0,0 +1,313 @@
+Hello! 👽
+
+**DeepSeek-Coder** is a powerful AI model designed to assist with coding-related tasks, including code generation, debugging, optimization, and more. Here’s how you can use it:  
+
+### **1. Online Access (Web & Playground)**  
+You can try **DeepSeek-Coder** for free on the official website:  
+🔗 [https://deepseek.com](https://deepseek.com)  
+
+Just type your coding questions (e.g., "Write a Python function to sort a list") and get instant AI-generated responses.  
+
+### **2. API Access**  
+If you want to integrate **DeepSeek-Coder** into your applications, you can use the API. Check the official documentation for details.  
+
+### **3. Local Deployment (Open-Source Models)**  
+DeepSeek provides open-source models like **DeepSeek-Coder 6.7B/33B** on Hugging Face. You can download and run them locally:  
+🔗 [Hugging Face Model Hub](https://huggingface.co/deepseek-ai)  
+
+#### **Example: Running with Transformers**  
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
+
+input_text = "Write a Python function to reverse a string."
+inputs = tokenizer(input_text, return_tensors="pt")
+outputs = model.generate(**inputs, max_length=200)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+### **4. Supported Features**  
+👽 **Code Generation** (Python, C++, Java, etc.)  
+👽 **Code Debugging & Explanation**  
+👽 **Code Optimization & Refactoring**  
+👽 **Docstring & Comment Generation**  
+👽 **Algorithm & Data Structure Help**  
+
+### **5. Tips for Best Results**  
+- Be **specific** in your prompts (e.g., "Write a Python function to merge two sorted lists").  
+- Provide **context** if needed (e.g., "I'm working with PyTorch, help me fix this CUDA error").  
+- Ask for **explanations** if you want to understand the code.  
+
+---
+
+**Q: Can i run deepseekcoder on android-linux?**
+
+A: Yes! You can run **DeepSeek-Coder** on an **Android-Linux** environment (e.g., using **Termux** or a **Linux chroot**), but with some limitations depending on the model size and your device's hardware. Here's how:
+
+### **Option 1: Running in Termux (Android)**
+#### **Requirements**:
+- **Termux** (from [F-Droid](https://f-droid.org/en/packages/com.termux/))
+- **Python & pip** (install in Termux)
+- **A lightweight model** (e.g., `deepseek-coder-1.3b` or quantized versions)
+
+#### **Steps**:
+1. **Install Termux & dependencies**:
+   ```bash
+   pkg update && pkg upgrade
+   pkg install python git wget
+   pip install transformers torch sentencepiece
+   ```
+2. **Load the model** (example with `deepseek-coder-1.3b`):
+   ```python
+   from transformers import AutoModelForCausalLM, AutoTokenizer
+
+   model_name = "deepseek-ai/deepseek-coder-1.3b-instruct"
+   tokenizer = AutoTokenizer.from_pretrained(model_name)
+   model = AutoModelForCausalLM.from_pretrained(model_name)
+
+   prompt = "Write a Python function to reverse a string."
+   inputs = tokenizer(prompt, return_tensors="pt")
+   outputs = model.generate(**inputs, max_length=200)
+   print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+   ```
+   - **Note**: Larger models (6.7B/33B) may not fit in RAM on most phones.
+
+3. **Use quantized models** (for lower RAM usage):
+   - Try **GGUF-quantized** models via `llama.cpp` (works in Termux):
+     ```bash
+     pip install llama-cpp-python
+     wget https://huggingface.co/TheBloke/deepseek-coder-6.7B-instruct-GGUF/resolve/main/deepseek-coder-6.7b-instruct.Q4_K_M.gguf
+     ```
+     Then load it with:
+     ```python
+     from llama_cpp import Llama
+     llm = Llama(model_path="deepseek-coder-6.7b-instruct.Q4_K_M.gguf")
+     print(llm("Write a Python function to reverse a string."))
+     ```
+
+### **Option 2: Linux Deploy (Full Linux on Android)**
+If your device supports it (e.g., with **Linux Deploy** or **UserLAnd**), you can run a full Linux distro (Ubuntu/Debian) and follow standard Linux instructions:
+```bash
+# In the Linux environment
+git clone https://github.com/deepseek-ai/deepseek-coder
+cd deepseek-coder
+pip install -r requirements.txt
+python run_inference.py
+```
+- **Pros**: Full GPU support (if your phone has a Linux-compatible GPU).
+- **Cons**: Complex setup, requires root/unlocked bootloader for some devices.
+
+
+### **Performance Considerations**
+- **RAM**: 1.3B needs ~3GB RAM, 6.7B needs ~16GB (quantized helps).
+- **Storage**: Models take 2GB+ (1.3B) to 40GB+ (33B).
+- **Speed**: Expect slow inference on CPUs (~1 token/sec).
+
+
+### **Alternative: Use the API**
+If local execution is too slow, use the **DeepSeek API** (if available) via Python:
+```python
+import requests
+response = requests.post("https://api.deepseek.com/coder", json={"prompt": "Write Python code to reverse a string"})
+print(response.json())
+```
+
+---
+
+**Q: How storage would be installing deepseek coder thru termux?**
+
+A: Installing **DeepSeek-Coder** in **Termux** (Android) requires careful storage management, as AI models are large. Here's a breakdown of storage needs and optimization tips:
+
+---
+
+### **1. Model Sizes (Approximate)**
+| Model                | Disk Space (Full Precision) | Quantized (GGUF) |
+|----------------------|----------------------------|------------------|
+| DeepSeek-Coder 1.3B  | ~2.5 GB                    | ~0.8 GB (Q4_K_M) |
+| DeepSeek-Coder 6.7B  | ~13 GB                     | ~4 GB (Q4_K_M)   |
+| DeepSeek-Coder 33B   | ~60 GB+                    | ~20 GB (Q4_K_M)  |
+
+**Note**: Quantized models (e.g., GGUF) reduce size but may lose slight accuracy.
+
+---
+
+### **2. Storage Requirements in Termux**
+- **Termux Limits**:  
+  - Default storage: ~10-15 GB (varies by device).  
+  - External SD card support (needs manual setup).  
+- **Recommended for Termux**:  
+  - Use **1.3B model** (quantized: ~0.8 GB) or **6.7B quantized** (~4 GB) if your device has space.  
+  - Avoid 33B (too large for most phones).  
+
+---
+
+### **3. Step-by-Step Installation (Optimized for Storage)**
+#### **Option A: Small Setup (1.3B Quantized)**
+```bash
+# Install dependencies
+pkg update && pkg upgrade
+pkg install python git wget
+pip install llama-cpp-python
+
+# Download a quantized 1.3B model (GGUF format)
+wget https://huggingface.co/TheBloke/deepseek-coder-1.3B-instruct-GGUF/resolve/main/deepseek-coder-1.3b-instruct.Q4_K_M.gguf
+
+# Run inference
+python -c "
+from llama_cpp import Llama
+llm = Llama(model_path='deepseek-coder-1.3b-instruct.Q4_K_M.gguf')
+print(llm('Write a Python function to reverse a string.'))
+"
+```
+**Storage Used**: ~1 GB (model + dependencies).  
+
+---
+
+#### **Option B: Medium Setup (6.7B Quantized)**
+```bash
+# Download 6.7B quantized (~4 GB)
+wget https://huggingface.co/TheBloke/deepseek-coder-6.7B-instruct-GGUF/resolve/main/deepseek-coder-6.7b-instruct.Q4_K_M.gguf
+
+# Run with reduced RAM usage (--n_ctx 512 lowers memory)
+python -c "
+from llama_cpp import Llama
+llm = Llama(model_path='deepseek-coder-6.7b-instruct.Q4_K_M.gguf', n_ctx=512)
+print(llm('Explain bubble sort in Python.'))
+"
+```
+**Storage Used**: ~4.5 GB.  
+
+---
+
+### **4. Storage Optimization Tips**
+1. **Use Quantized Models**:  
+   - Prefer `Q4_K_M` or `Q5_K_M` GGUF models (balance size/quality).  
+   - Find them on [TheBloke's Hugging Face](https://huggingface.co/TheBloke).  
+
+2. **Store Models on SD Card**:  
+   - Symlink the model to Termux:  
+     ```bash
+     ln -s /storage/XXXX-XXXX/deepseek-coder.gguf ~/deepseek-model.gguf
+     ```  
+     (Replace `XXXX-XXXX` with your SD card path).  
+
+3. **Clean Cache**:  
+   ```bash
+   pip cache purge
+   rm -rf ~/.cache/huggingface
+   ```
+
+4. **Use `termux-setup-storage`**:  
+   Grants Termux access to phone storage for extra space.  
+
+---
+
+### **5. Expected Performance**
+- **1.3B Model**: ~1-2 tokens/sec on CPU (usable for small tasks).  
+- **6.7B Model**: ~0.5-1 token/sec (slow but functional).  
+- **RAM Usage**: 1.3B needs ~1.5GB RAM; 6.7B needs ~6GB (close Termux apps to free memory).  
+
+---
+
+### **Alternative: Cloud/API**
+If storage is critical, use the **DeepSeek API** (if available) instead of local models:  
+```python
+import requests
+response = requests.post("https://api.deepseek.com/v1/chat", json={"model": "deepseek-coder", "messages": [{"role": "user", "content": "Write Fibonacci in Python"}]})
+print(response.json())
+```
+
+---
+
+### **Summary**
+- **For most phones**: 1.3B quantized (~1GB) is practical.  
+- **High-end phones**: 6.7B quantized (~4GB) if storage allows.  
+- **Avoid 33B** (unless you have a rooted device with 64GB+ free).  
+
+Let me know if you need help setting it up! 
+
+---
+
+**Q: What u suggest for android/samsung galaxy a53 model 1.3B or 6.7B ?**
+
+A: For a **Samsung Galaxy A53** (typically with **6GB RAM** and **128GB storage**), here’s my recommendation for running **DeepSeek-Coder** locally in Termux:
+
+---
+
+### **Recommended Choice: `1.3B Quantized` (GGUF)**
+#### **Why?**
+1. **RAM Limits**:  
+   - The A53 has **6GB RAM**, but Android uses ~2-3GB for the OS, leaving ~3-4GB free.  
+   - The **1.3B model** needs ~1.5GB RAM (quantized), while the **6.7B** needs ~6GB (too close to the limit).  
+
+2. **Storage**:  
+   - 1.3B quantized: **~0.8GB** (fits easily).  
+   - 6.7B quantized: **~4GB** (manageable but tight if you have other apps/media).  
+
+3. **Speed**:  
+   - 1.3B: **~2-3 tokens/sec** (usable for small tasks).  
+   - 6.7B: **~0.5-1 token/sec** (painfully slow on mobile CPU).  
+
+---
+
+### **How to Set Up 1.3B in Termux**
+```bash
+# Install dependencies
+pkg update && pkg upgrade
+pkg install python git wget
+pip install llama-cpp-python
+
+# Download the quantized 1.3B model (Q4_K_M)
+wget https://huggingface.co/TheBloke/deepseek-coder-1.3B-instruct-GGUF/resolve/main/deepseek-coder-1.3b-instruct.Q4_K_M.gguf
+
+# Run inference (adjust n_ctx for RAM savings)
+python -c "
+from llama_cpp import Llama
+llm = Llama(model_path='deepseek-coder-1.3b-instruct.Q4_K_M.gguf', n_ctx=512)
+print(llm('Write a Python function to check if a number is prime.'))
+"
+```
+
+---
+
+### **If You Still Want to Try 6.7B**
+#### **Requirements**:
+- Close all background apps.  
+- Enable **swap memory** (if rooted) or use **zRAM** (advanced Termux tweaks).  
+- Expect **very slow speeds** (~1 word every 2 seconds).  
+
+```bash
+wget https://huggingface.co/TheBloke/deepseek-coder-6.7B-instruct-GGUF/resolve/main/deepseek-coder-6.7b-instruct.Q4_K_M.gguf
+python -c "
+from llama_cpp import Llama
+llm = Llama(model_path='deepseek-coder-6.7b-instruct.Q4_K_M.gguf', n_ctx=256)  # lower ctx to save RAM
+print(llm('Explain Python decorators briefly.'))
+"
+```
+
+---
+
+### **Alternatives**
+1. **Use the API** (if available):  
+   No storage/RAM limits, but requires internet.  
+   ```python
+   import requests
+   response = requests.post("https://api.deepseek.com/coder", json={"prompt": "Write a Python calculator"})
+   print(response.text)
+   ```
+
+2. **Remote Server**:  
+   Run the model on a PC/Raspberry Pi and access it from your phone via `curl`.  
+
+---
+
+### **Final Verdict**
+- **For daily use**: Stick with **1.3B quantized**. It’s the only practical option for your A53.  
+- **For experiments**: Try 6.7B, but expect crashes/slowness.  
+- **For heavy tasks**: Use the **DeepSeek web app** or API.  
+
+
+