Coding | SUMAN

Best LLMs for Coding in 2026: Ranked from Number 1 to Last

Fri, 17 Apr 2026 00:00:00 +0000

Not all AI models are created equal, especially when it comes to writing, editing, and reasoning about code. With dozens of models now available across cloud APIs and local runtimes like Ollama, it is easy to get lost. This post ranks the best coding LLMs in 2026 based on real benchmarks: SWE-Bench (real GitHub issue resolution), LiveCodeBench (unseen competitive programming), and BFCL (tool/function calling accuracy).

Tier 1 - Cloud / API Models (Best Overall)

These are the top-performing models available via API. If output quality is your priority and cost is secondary, start here.

1. Claude Opus 4.7 - Best for Agentic Coding

SWE-Bench: 87.6% (1st in the world)
Best model for multi-step, autonomous coding tasks (Claude Code, Cursor, agentic loops)
Dominates real-world GitHub issue resolution, not just toy benchmarks
Use when you need the model to think, plan, and execute across files

2. Claude Sonnet 4.5 - Best Daily Driver

SWE-Bench: 82%
Faster and cheaper than Opus 4.7, with nearly the same agentic performance
The sweet spot for production coding workflows, great for CI/CD integration
Ideal for developers who run dozens of tasks a day

3. Gemini 3 Pro - Strong All-Rounder

LiveCodeBench: 79.7% | SWE-Bench: 76.2%
Google’s most capable coding model, competitive across all benchmark types
Excellent context handling and multimodal support
Good alternative if you are already in the Google ecosystem

4. GPT-5.1 / GPT-5 - Reliable OpenAI Option

SWE-Bench: 76.3% (GPT-5.1) / 74.9% (GPT-5)
Solid across the board, well-integrated with GitHub Copilot and OpenAI’s ecosystem
Strong instruction following and function calling

5. Kimi K2 Thinking - Best Raw Code Generation

LiveCodeBench: 83.1% (1st on this benchmark)
Moonshot AI’s reasoning model, excels at algorithm writing and competitive programming
Strong SWE-Bench score of 71.3%
New contender worth watching closely

6. Grok 3 (Beta) - Competitive Coding Beast

LiveCodeBench: 79.4%
xAI’s flagship, particularly strong on pure code generation tasks
Less proven on agentic/real-world benchmarks but improving fast

7. OpenAI o3-mini - Best Budget Reasoning Model

LiveCodeBench: 74.1% | SWE-Bench: 61% | BFCL: 65.1%
The most cost-efficient reasoning model for coding
Great for developers who need chain-of-thought reasoning without paying for full o3

8. DeepSeek R1 - Best for Logic-Heavy Code

LiveCodeBench: 64.3% | MATH-500: 97.3%
Open-source model with exceptional mathematical and logical reasoning
Great for algorithmic problems, data structures, and ML code
Available on free tier via DeepSeek API, accessible from Bangladesh

Tier 2 - Local / Ollama Models (Free and Self-Hosted)

These models run fully locally via Ollama, LM Studio, or similar. No API costs, no internet required after download.

1. DeepSeek V3 0324 - Best Open Source Overall

LiveCodeBench: 41% | SWE-Bench: 38.8% | BFCL: 58.5%
The best locally runnable model for general coding tasks
MIT-licensed, fast on consumer hardware with quantized versions
Recommended first choice for Ollama users

2. Qwen2.5-Coder / Qwen2.5-VL-32B - Best Tool Use Locally

BFCL Tool Use: 62.8% (highest among open models)
Alibaba’s Qwen series is purpose-built for code
Excellent for function calling, structured output, and agentic tasks locally
Available in 7B, 14B, 32B sizes, runs well on mid-range GPUs

3. Llama 4 Behemoth - Best for Reasoning (High VRAM)

LiveCodeBench: 49.4% | MATH-500: 95%
Meta’s most capable open model, requires significant hardware
Best choice if you have a high-end GPU setup (48GB+ VRAM)

4. Llama 4 Maverick - Balanced Performance

LiveCodeBench: 41%
Good balance between model size and coding performance
Multimodal support and very long context window (up to 1M tokens)

5. Gemma 3 27B - Lightweight and Capable

MATH-500: 89% | BFCL: 59.1%
Google’s open model, surprisingly strong tool use for its size
Runs comfortably on consumer hardware (16-24GB VRAM)

6. GLM-4 / GLM-5 (ZhipuAI) - Decent but Outclassed

Usable for general coding, especially Chinese-language documentation
Significantly behind DeepSeek V3 and Qwen2.5 on every major benchmark
Consider only if you have specific GLM integration requirements

Best by Use Case

Use Case	Best Model
Agentic coding (Claude Code, Cursor)	Claude Opus 4.7
Everyday coding assistant	Claude Sonnet 4.5
Raw algorithm / competitive coding	Kimi K2 Thinking
Tool and function calling (API)	GPT-4.5 (69.9% BFCL)
Budget reasoning (API)	OpenAI o3-mini
Local - best overall	DeepSeek V3 0324
Local - tool/function calling	Qwen2.5-Coder 32B
Local - low VRAM (8GB)	Qwen2.5-Coder 7B or Gemma 3
Free API (accessible in Bangladesh)	DeepSeek API or Groq (Llama/Qwen)

Key Takeaways

Claude dominates agentic coding. If you are using any coding agent (Claude Code, Cursor, Continue), Claude Opus 4.7 or Sonnet 4.5 will outperform everything else on real-world tasks.
For local/Ollama, skip GLM and use DeepSeek V3 or Qwen2.5. These are objectively stronger on every benchmark and have better English instruction-following.
The agent matters as much as the model. The same model produces meaningfully better outputs in a well-engineered agent vs. a naive one.
Free options exist. DeepSeek’s free tier and Groq’s API (running Llama/Qwen) give you near-frontier model quality at zero cost, both accessible from Bangladesh without VPN.

Benchmark data sourced from Vellum AI Coding LLM Leaderboard, updated March 2026. Rankings reflect SWE-Bench Verified, LiveCodeBench, and BFCL scores where available.

Converting Your Web App to an Android App Using WebView

Fri, 27 Mar 2026 00:00:00 +0000

Converting Web App to an Android App Using WebView

DEPLOY YOUR REACT APP (Vercel)

✅ Build your project (LOCAL) 📂 Open your React project folder G:\lzproject\lzapp-v2 🔹 Open Terminal in this folder

👉 In VS Code:

Terminal → New Terminal 🔹 Run this command: npm run build ✅ Expected result:

You will see a new folder:

dist/

👉 This is your production build

🌐 Deploy to Vercel 🔹 Step 1 — Open Vercel

Go to: 👉 https://vercel.com

🔹 Step 2 — Login

Use:

GitHub (recommended) OR Google 🔹 Step 3 — Import Project

Click:

Add New → Project 🔹 Step 4 — Select your repo

If your project is already on GitHub:

👉 Select:

lzapp-v2 🔹 Step 5 — Configure

Vercel auto-detects Vite 👍

Check:

Framework: Vite Build Command: npm run build Output Directory: dist

👉 Click:

Deploy ⏳ Wait 1–2 minutes ✅ STEP 6 — Get your URL

After deploy, you’ll get:

https://your-project-name.vercel.app

✅ Any update- TEST BEFORE DEPLOY

Run locally:

npm run dev

👉 Open: http://localhost:5173

THEN DEPLOY AGAIN

npm run build

Every time you change UI:

1. Edit React (App.jsx / CSS)
2. npm run build
3. Push or redeploy Vercel
4. Open Android app → updated automatically, See updated UI

🚀 1. Install Android Studio (Setup)

🔹 Download & Install

Head over to the official Android Developer website: https://developer.android.com/studio

Download and install the latest version of Android Studio. The installation process is straightforward and includes everything you need to get started.

🔹 During Setup

When prompted during installation, make sure to select:

✅ Standard installation
✅ Install Android SDK
✅ Install Emulator (optional, but useful for testing)

🔹 After Installation

Launch Android Studio and click “New Project” to begin.

📱 2. Create New Android Project

In the New Project wizard, select:

Template: Empty Views Activity
Language: Java (simpler for beginners)
Minimum SDK: API 21 (Android 5.0) - this covers about 95% of active Android devices

Fill in the project details:

Name: LzApp
Package: com.yourname.lzapp

Click Finish and let Android Studio set up your project.

🌐 3. Add Internet Permission

Your web app will need internet access, so we need to add the necessary permission.

Navigate to: app > src > main > AndroidManifest.xml

Add this line just above the <application> tag:

<uses-permission android:name="android.permission.INTERNET" />

🌍 4. Add WebView in Layout

Now let’s set up the user interface. Open: res > layout > activity_main.xml

Replace the entire contents with:

<?xml version="1.0" encoding="utf-8"?>
<WebView xmlns:android="http://schemas.android.com/apk/res/android"
 android:id="@+id/webView"
 android:layout_width="match_parent"
 android:layout_height="match_parent" />

This creates a full-screen WebView that will display your web app.

⚙️ 5. Load Your Vercel App in WebView

Open: MainActivity.java

Replace the entire file with:

package com.yourname.landzoning;

import android.os.Bundle;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

 WebView webView;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);

 webView = new WebView(this);
 setContentView(webView);

 webView.setWebViewClient(new WebViewClient());

 webView.getSettings().setJavaScriptEnabled(true);
 webView.getSettings().setDomStorageEnabled(true);

 webView.loadUrl("https://your-vercel-app.vercel.app");
 }
}

Important: Replace https://your-vercel-app.vercel.app with your actual deployed Vercel URL.

🔙 6. Handle Back Button (IMPORTANT)

To provide a native app experience, we need to handle the back button properly. Add this method to your MainActivity.java:

@Override
public void onBackPressed() {
 if (webView.canGoBack()) {
 webView.goBack();
 } else {
 super.onBackPressed();
 }
}

This allows users to navigate back through your web app’s history before exiting the app.

⚡ 7. Improve WebView (Production Ready Basics)

Let’s enhance the WebView settings for better performance and user experience. Add these lines after the existing settings in onCreate():

webView.getSettings().setLoadWithOverviewMode(true);
webView.getSettings().setUseWideViewPort(true);
webView.getSettings().setBuiltInZoomControls(true);
webView.getSettings().setDisplayZoomControls(false);

These settings ensure your web app displays properly on different screen sizes and provides zoom controls.

🎬 8. Add Splash Screen

A splash screen provides a professional first impression. Let’s add one.

Step 1: Create splash layout

Create a new file: res > layout > splash.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
 xmlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:gravity="center"
 android:background="#ffffff"
 android:layout_width="match_parent"
 android:layout_height="match_parent">

 <TextView
 android:text="Land Zoning BD"
 android:textSize="24sp"
 android:textStyle="bold"
 android:textColor="#000"/>

</LinearLayout>

Step 2: Create SplashActivity

Right-click on your package → New → Activity → Empty Activity Name: SplashActivity

Replace the code with:

package com.yourname.landzoning;

import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import androidx.appcompat.app.AppCompatActivity;

public class SplashActivity extends AppCompatActivity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.splash);

 new Handler().postDelayed(() -> {
 startActivity(new Intent(SplashActivity.this, MainActivity.class));
 finish();
 }, 2000); // 2 seconds
 }
}

Step 3: Make Splash First Screen

In AndroidManifest.xml, modify the activity declarations:

<activity android:name=".SplashActivity">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
 <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
</activity>

<activity android:name=".MainActivity" />

📦 9. Build APK (Production)

🔹 Build Debug APK

From the top menu: Build → Build APK(s)

After the build completes, click Locate to find your APK at: app/build/outputs/apk/debug/app-debug.apk

🔐 10. Build Release APK (IMPORTANT)

For distribution, you need a signed release APK.

Go to: Build → Generate Signed Bundle / APK

Choose:

APK
Create new keystore

Fill in:

Password
Key alias
Validity: 25 years

Then:

Select release
Finish

Your signed APK will be at: app-release.apk

🚀 11. Install on Phone

You can install the APK in two ways:

USB Method: Copy the APK to your phone and install it directly.
ADB Method: Connect your phone via USB and run:
```
adb install app-release.apk
```

⚠️ Important Tips for Your GIS App

Since you’re working with Leaflet, Firebase, and Vercel:

🔹 Security & Performance

✅ Ensure HTTPS (Vercel handles this automatically)
❌ Avoid mixed content (no HTTP resources in HTTPS pages)

🔹 Map Performance Optimization

Add these settings for better map rendering:

webView.getSettings().setAllowFileAccess(true);
webView.getSettings().setAllowContentAccess(true);

🎯 Next Steps

Once you have the basic WebView wrapper working, consider these enhancements:

Offline Caching: Implement PWA features for offline functionality
Native Loading Indicators: Add progress bars and loading states
Pull-to-Refresh: Implement swipe-to-refresh functionality
Push Notifications: Integrate Firebase Cloud Messaging
Custom Toolbar: Add navigation controls that feel native
Play Store Release: Prepare your app for Google Play Store distribution

⚠️ If Build Issues Occur

Sometimes after moving, you may see errors like:

Gradle path issue
SDK not found

Fix:

🔹 1. Re-sync Gradle

File → Sync Project with Gradle Files

🔹 2. Clean & Rebuild

Build → Clean Project
Build → Rebuild Project

🔹 3. Check SDK Path

File → Project Structure → SDK Location

Make sure it points to something like:

C:\Users\Dell\AppData\Local\Android\Sdk

👉 Summary

You’re essentially creating a native Android wrapper around your web application:

React App (Vercel) → Android WebView Wrapper → APK App

web app development

Fri, 27 Mar 2026 00:00:00 +0000

Web App

You’ve already built a solid Web + GIS dashboard system. Now we’ll upgrade it into a full ecosystem:

✅ Android App (Data Control Panel) ✅ Realtime Database (replace Google Sheets) ✅ Web App (auto-sync updates)

🧠 System Architecture (Upgraded)

🔄 Current (Your Setup) Google Sheet → Web App (Vercel) → Map UI

🚀 New System (Recommended) Android App → Firebase / Supabase DB → Web App (Vercel)

✔ No more manual Google Sheet editing ✔ Real-time sync ✔ Mobile control panel ✔ Scalable + faster

⚙️ STEP 1: Choose Backend (VERY IMPORTANT)

🥇 Best Option: Firebase (Recommended)

Realtime database
Easy Android integration
Free tier enough

Alternative:

Supabase (PostgreSQL)
Node.js API + MongoDB (more control)

👉 I’ll proceed with Firebase Firestore (best for your case)

🔥 STEP 2: Database Structure

Replace your Excel with this structure:

Collection: upazila_progress { “id”: “123”, “division”: “Dhaka”, “district”: “Gazipur”, “upazila”: “Kaliganj”, “status”: “done”, // done | ongoing | todo “updated_at”: “2026-03-24T10:00:00” }

🌐 STEP 3: Update Your Web App (IMPORTANT)

Replace Google Sheets API with Firebase fetch.

Install Firebase in your web project npm install firebase

Firebase config (JS) import { initializeApp } from “firebase/app”; import { getFirestore, collection, getDocs } from “firebase/firestore”;

const firebaseConfig = { apiKey: “XXXX”, authDomain: “XXXX”, projectId: “XXXX”, };

const app = initializeApp(firebaseConfig); const db = getFirestore(app);

export async function fetchUpazilaData() { const querySnapshot = await getDocs(collection(db, “upazila_progress”)); return querySnapshot.docs.map(doc => doc.data()); }

👉 Replace your Google Sheet logic with this.

📱 STEP 4: Android App (Core Part)

We build a Minimal Admin App

Features:

Upazila list
Status change (Done / Ongoing / ToDo)
Search
Dashboard summary

🏗 Tech Stack

Kotlin
Firebase Firestore
Jetpack Compose (or XML if you prefer)

📲 Android UI Structure Screens:

Dashboard
Upazila List
Edit Status

🧩 Example Code

Firebase Setup (Android) val db = FirebaseFirestore.getInstance()
Fetch Data fun getUpazilas(onResult: (List) -> Unit) { db.collection(“upazila_progress”) .get() .addOnSuccessListener { result -> val list = result.map { doc -> Upazila( id = doc.id, name = doc.getString(“upazila”) ?: “”, status = doc.getString(“status”) ?: “todo” ) } onResult(list) } }
Update Status (🔥 KEY PART) fun updateStatus(id: String, newStatus: String) { db.collection(“upazila_progress”) .document(id) .update(“status”, newStatus) }

👉 This is what replaces Google Sheets editing.

Simple UI (XML idea)

🔄 STEP 5: Real-Time Sync (Important Upgrade)

Instead of getDocs(), use listener:

Web + Android both onSnapshot(collection(db, “upazila_progress”), (snapshot) => { // auto update map });

👉 Now: ✔ Android change → instantly updates web map ✔ No refresh needed

📊 STEP 6: Dashboard Logic (Same as Web)

Count status:

val done = list.count { it.status == “done” } val ongoing = list.count { it.status == “ongoing” } val todo = list.count { it.status == “todo” }

🎯 FINAL RESULT Android App

✔ Change status ✔ View progress ✔ Control system

Web App

✔ Map auto-updates ✔ No Google Sheets ✔ Real-time sync

🚀 OPTIONAL ADVANCED FEATURES

If you want next-level:

🔐 Login system (Admin only) 📍 GPS tagging per update 📸 Upload field images 📶 Offline sync (Firestore supports) 📊 Analytics dashboard

⚠️ Important Advice

👉 Do NOT keep Google Sheets now 👉 Firebase = faster + scalable 👉 Your current map code can stay mostly same

🧱 STEP 1: Add Firebase to Your Project

Go to: https://console.firebase.google.com

→ Create project: landzoning

Then:

Enable: ✅ Firestore Database ✅ (Optional) Authentication later

🔑 Get Config

You’ll get something like:

const firebaseConfig = { apiKey: “XXXX”, authDomain: “XXXX”, projectId: “XXXX”, };

📦 STEP 2: Modify Your GitHub Code

In your repo 👉 Landzoning-main

Install Firebase npm install firebase
Create New File 📁 /src/firebase.js import { initializeApp } from “firebase/app”; import { getFirestore } from “firebase/firestore”;

const firebaseConfig = { apiKey: “YOUR_KEY”, authDomain: “YOUR_DOMAIN”, projectId: “YOUR_PROJECT_ID”, };

const app = initializeApp(firebaseConfig); export const db = getFirestore(app);

🔁 STEP 3: Replace Google Sheet Logic

Find your current file where you load Excel/Sheet data (Probably something like fetchData.js, App.js, or map.js)

❌ REMOVE (Old) // Google Sheet / XLSX loading fetch(“bdupazila.xlsx”)

✅ ADD (New Firebase Fetch) import { collection, onSnapshot } from “firebase/firestore”; import { db } from “./firebase”;

export function listenToUpazilaData(callback) { const unsub = onSnapshot(collection(db, “upazila_progress”), (snapshot) => { const data = snapshot.docs.map(doc => ({ id: doc.id, …doc.data() })); callback(data); });

return unsub; }

🗺 STEP 4: Connect with Your Map

Where you currently update map colors:

Replace your data source with:

listenToUpazilaData((data) => { updateMap(data); // your existing function updateStats(data); // your dashboard logic });

🎨 STEP 5: Keep Your Map Styling (NO CHANGE)

Your existing:

Leaflet map
GeoJSON boundaries
Color logic

👉 KEEP EVERYTHING SAME 👉 Only change data source

📊 STEP 6: Status Color Mapping (Ensure This)

function getColor(status) { switch (status) { case “done”: return “#22c55e”; // green case “ongoing”: return “#facc15”; // yellow default: return “#9ca3af”; // gray } }

🧪 STEP 7: Upload Initial Data to Firebase

Go to Firestore → Collection: upazila_progress

Add documents manually OR use script:

import { collection, addDoc } from “firebase/firestore”;

const data = [ { upazila: “Kaliganj”, status: “done” }, ];

data.forEach(async (item) => { await addDoc(collection(db, “upazila_progress”), item); }); 🔄 RESULT Now your system becomes: Android App → Firebase → Web Map (Auto Update)

✔ No refresh needed ✔ Real-time updates ✔ Centralized control

📱 NEXT (Android Integration)

Your Android app will:

db.collection(“upazila_progress”) .document(id) .update(“status”, “done”)

👉 Web updates instantly 🔥

🚀 BONUS: Performance Upgrade

Use indexing:

Firestore → Indexes → Add:

status ASC district ASC ⚠️ Common Mistakes

❌ Using getDocs() (not realtime) ✅ Use onSnapshot()

❌ Keeping Excel logic ✅ Fully remove it