diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vue
index 58086da955..bb571bf3c8 100644
--- a/apps/desktop/src/components/connection/ConnectionDialog.vue
+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue
@@ -826,6 +826,7 @@ const driverProfiles: Record<
     label: "Elasticsearch",
     icon: "elasticsearch",
   },
+  hbase: { type: "hbase", port: 8080, user: "", label: "Apache HBase", icon: "hbase" },
   qdrant: { type: "qdrant", port: 6333, user: "", label: "Qdrant", icon: "qdrant" },
   milvus: { type: "milvus", port: 19530, user: "root", label: "Milvus", icon: "milvus" },
   weaviate: { type: "weaviate", port: 8080, user: "", label: "Weaviate", icon: "weaviate" },
@@ -2200,6 +2201,7 @@ const iconTypeMap: Record<string, string> = {
   sqlserver: "sqlserver",
   oracle: "oracle",
   elasticsearch: "elasticsearch",
+  hbase: "hbase",
   qdrant: "qdrant",
   milvus: "milvus",
   weaviate: "weaviate",
@@ -2279,6 +2281,7 @@ const dbOptions: DbOption[] = [
   { value: "sqlite", label: "SQLite" },
   { value: "sqlserver", label: "SQL Server" },
   { value: "elasticsearch", label: "Elasticsearch" },
+  { value: "hbase", label: "Apache HBase" },
   { value: "qdrant", label: "Qdrant" },
   { value: "milvus", label: "Milvus" },
   { value: "weaviate", label: "Weaviate" },
@@ -2380,7 +2383,7 @@ const dbCategoryDefinitions: Array<{
   {
     key: "document",
     titleKey: "connection.databaseCategoryDocument",
-    optionValues: ["mongodb", "redis", "elasticsearch", "manticoresearch", "cassandra"],
+    optionValues: ["mongodb", "redis", "elasticsearch", "hbase", "manticoresearch", "cassandra"],
   },
   {
     key: "graph_ai",
@@ -2495,10 +2498,10 @@ const sqliteExtensionPaths = computed({
     form.value.url_params = setSqliteExtensionPaths(form.value.url_params, value);
   },
 });
-const tlsCapableDatabaseTypes = new Set<DatabaseType>(["mysql", "starrocks", "postgres", "redshift", "gaussdb", "kwdb", "opengauss", "questdb", "dameng", "redis", "etcd", "clickhouse", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "influxdb"]);
+const tlsCapableDatabaseTypes = new Set<DatabaseType>(["mysql", "starrocks", "postgres", "redshift", "gaussdb", "kwdb", "opengauss", "questdb", "dameng", "redis", "etcd", "clickhouse", "elasticsearch", "hbase", "qdrant", "milvus", "weaviate", "chromadb", "influxdb"]);
 const supportsTlsToggle = computed(() => tlsCapableDatabaseTypes.has(form.value.db_type));
 const supportsCaCertificatePath = computed(() => form.value.db_type === "clickhouse");
-const supportsGenericUrlParams = computed(() => form.value.db_type !== "manticoresearch");
+const supportsGenericUrlParams = computed(() => form.value.db_type !== "manticoresearch" && form.value.db_type !== "hbase");
 const bareMysqlProfiles = new Set(["doris", "selectdb", "oceanbase"]);
 const supportsMysqlTlsOptions = computed(() => form.value.db_type === "starrocks" || (form.value.db_type === "mysql" && !bareMysqlProfiles.has(selectedType.value)));
 const supportsMysqlCleartextPasswordAuth = computed(() => form.value.db_type === "mysql" && !bareMysqlProfiles.has(selectedType.value));
@@ -5902,7 +5905,7 @@ function openExternalUrl(url: string) {
                     <PasswordInput v-model="form.password" class="col-span-3" />
                   </div>
 
-                  <div class="grid grid-cols-4 items-center gap-4">
+                  <div v-if="form.db_type !== 'hbase'" class="grid grid-cols-4 items-center gap-4">
                     <Label :class="connectionLabelClass">{{ databaseLabel }}</Label>
                     <Input v-model="form.database" class="col-span-3" :placeholder="databasePlaceholder" />
                   </div>
diff --git a/apps/desktop/src/components/hbase/HBaseBrowser.vue b/apps/desktop/src/components/hbase/HBaseBrowser.vue
new file mode 100644
index 0000000000..915a2c895d
--- /dev/null
+++ b/apps/desktop/src/components/hbase/HBaseBrowser.vue
@@ -0,0 +1,508 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { Braces, DatabaseZap, ListFilter, Loader2, Plus, RefreshCw, ScanSearch, TableProperties, Trash2 } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+
+import DataGrid from "@/components/grid/DataGrid.vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import ErrorBanner from "@/components/ui/ErrorBanner.vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import type { CustomSaveHandler } from "@/composables/useDataGridEditor";
+import { useToast } from "@/composables/useToast";
+import * as api from "@/lib/backend/api";
+import type { CellValue } from "@/lib/dataGrid/cellValue";
+import { encodeHBaseTextInput, hbaseCellInput } from "@/lib/hbase/hbaseValues";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import type { QueryResult } from "@/types/database";
+import type { HBaseCellInput, HBasePutRowInput, HBaseRow, HBaseTableSchema, HBaseValueEncoding } from "@/types/hbase";
+
+const props = defineProps<{
+  tabId: string;
+  connectionId: string;
+  namespace: string;
+  table: string;
+  createTableOnOpen?: boolean;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+
+type LookupMode = "prefix" | "exact";
+
+const rows = ref<HBaseRow[]>([]);
+const loading = ref(false);
+const error = ref("");
+const lookupMode = ref<LookupMode>("prefix");
+const rowKeyInput = ref("");
+const rowLimit = ref("100");
+const truncated = ref(false);
+const elapsedMs = ref(0);
+const schema = ref<HBaseTableSchema>();
+const schemaLoading = ref(false);
+const schemaDialogOpen = ref(false);
+const writeDialogOpen = ref(false);
+const writeJson = ref("");
+const writeLoading = ref(false);
+const writeError = ref("");
+const createTableDialogOpen = ref(false);
+const createTableName = ref("");
+const createColumnFamilies = ref("");
+const createTableLoading = ref(false);
+const createTableError = ref("");
+const deleteTableDialogOpen = ref(false);
+const deleteTableLoading = ref(false);
+const deleteTableError = ref("");
+
+const hasTable = computed(() => props.table.trim().length > 0);
+const readOnly = computed(() => connectionStore.getConfig(props.connectionId)?.read_only === true);
+const qualifiedTableLabel = computed(() => {
+  if (!hasTable.value) return props.namespace;
+  return props.namespace && props.namespace !== "default" ? `${props.namespace}:${props.table}` : props.table;
+});
+
+const gridColumns = computed(() => {
+  const columns = new Set<string>();
+  for (const row of rows.value) {
+    for (const cell of row.cells) columns.add(cell.column);
+  }
+  return ["_row_key", ...Array.from(columns).sort((left, right) => left.localeCompare(right))];
+});
+
+const gridResult = computed<QueryResult>(() => {
+  const columns = gridColumns.value;
+  const data = rows.value.map((row) => {
+    const cells = new Map(row.cells.map((cell) => [cell.column, cell.value]));
+    return columns.map((column) => (column === "_row_key" ? row.rowKey : (cells.get(column) ?? null)));
+  });
+  return {
+    columns,
+    column_types: columns.map((column) => (column === "_row_key" ? "ROW_KEY" : "HBASE_CELL")),
+    column_sortables: columns.map(() => false),
+    rows: data,
+    affected_rows: data.length,
+    execution_time_ms: elapsedMs.value,
+    total_is_exact: !truncated.value,
+  };
+});
+
+const customSaveHandler = computed<CustomSaveHandler>(() => ({
+  save: saveGridChanges,
+  preview: previewGridChanges,
+  supportsInsert: false,
+  canInsert: false,
+  canDelete: !readOnly.value,
+  readonlyColumns: ["_row_key"],
+  targetLabel: qualifiedTableLabel.value,
+}));
+
+watch(
+  () => [props.connectionId, props.namespace, props.table] as const,
+  () => {
+    rows.value = [];
+    schema.value = undefined;
+    rowKeyInput.value = "";
+    if (hasTable.value) void refreshRows();
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.createTableOnOpen,
+  (requested) => {
+    if (!requested) return;
+    openCreateTableDialog();
+    const tab = queryStore.tabs.find((candidate) => candidate.id === props.tabId);
+    if (tab) tab.hbaseCreateTableOnOpen = undefined;
+  },
+  { immediate: true },
+);
+
+async function refreshRows() {
+  if (loading.value || !hasTable.value) return;
+  loading.value = true;
+  error.value = "";
+  const startedAt = performance.now();
+  try {
+    if (lookupMode.value === "exact" && rowKeyInput.value) {
+      const rowKey = encodeHBaseTextInput(rowKeyInput.value);
+      const row = await api.hbaseGetRow(props.connectionId, props.namespace, props.table, rowKey.value, rowKey.encoding);
+      rows.value = row ? [row] : [];
+      truncated.value = false;
+    } else {
+      const result = await api.hbaseScanRows(props.connectionId, props.namespace, props.table, rowKeyInput.value || undefined, Number(rowLimit.value));
+      rows.value = result.rows;
+      truncated.value = result.truncated;
+    }
+  } catch (caught) {
+    error.value = errorMessage(caught);
+  } finally {
+    elapsedMs.value = Math.round(performance.now() - startedAt);
+    loading.value = false;
+  }
+}
+
+async function openSchemaDialog() {
+  schemaDialogOpen.value = true;
+  if (schema.value) return;
+  schemaLoading.value = true;
+  try {
+    schema.value = await api.hbaseGetTableSchema(props.connectionId, props.namespace, props.table);
+  } catch (caught) {
+    error.value = errorMessage(caught);
+    schemaDialogOpen.value = false;
+  } finally {
+    schemaLoading.value = false;
+  }
+}
+
+async function openWriteDialog() {
+  if (schemaLoading.value) return;
+  error.value = "";
+  schemaLoading.value = true;
+  try {
+    schema.value ??= await api.hbaseGetTableSchema(props.connectionId, props.namespace, props.table);
+  } catch (caught) {
+    error.value = errorMessage(caught);
+    return;
+  } finally {
+    schemaLoading.value = false;
+  }
+  const family = schema.value.columnFamilies[0]?.name;
+  if (!family) {
+    error.value = t("hbase.noColumnFamilies");
+    return;
+  }
+  writeJson.value = JSON.stringify(
+    {
+      rowKey: "",
+      cells: {
+        [`${family}:qualifier`]: "value",
+      },
+    },
+    null,
+    2,
+  );
+  writeError.value = "";
+  writeDialogOpen.value = true;
+}
+
+function openCreateTableDialog() {
+  createTableError.value = "";
+  createTableName.value = "";
+  createColumnFamilies.value = "";
+  createTableDialogOpen.value = true;
+}
+
+async function writeRow() {
+  if (writeLoading.value) return;
+  writeLoading.value = true;
+  writeError.value = "";
+  try {
+    const input = parseWriteInput(writeJson.value);
+    await api.hbasePutRow(props.connectionId, props.namespace, props.table, input);
+    writeDialogOpen.value = false;
+    toast(t("hbase.rowSaved"));
+    await refreshRows();
+  } catch (caught) {
+    writeError.value = errorMessage(caught);
+  } finally {
+    writeLoading.value = false;
+  }
+}
+
+async function createTable() {
+  if (createTableLoading.value) return;
+  const families = createColumnFamilies.value
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+  createTableLoading.value = true;
+  createTableError.value = "";
+  try {
+    const createdTable = createTableName.value.trim();
+    await api.hbaseCreateTable(props.connectionId, props.namespace, createdTable, families);
+    createTableDialogOpen.value = false;
+    toast(t("hbase.tableCreated", { table: createdTable }));
+    await connectionStore.loadTables(props.connectionId, props.namespace);
+    if (!hasTable.value) {
+      const tab = queryStore.tabs.find((candidate) => candidate.id === props.tabId);
+      if (tab) tab.title = createdTable;
+      queryStore.updateSql(props.tabId, createdTable);
+    }
+  } catch (caught) {
+    createTableError.value = errorMessage(caught);
+  } finally {
+    createTableLoading.value = false;
+  }
+}
+
+async function deleteTable() {
+  if (deleteTableLoading.value) return;
+  deleteTableLoading.value = true;
+  deleteTableError.value = "";
+  try {
+    await api.hbaseDeleteTable(props.connectionId, props.namespace, props.table);
+    deleteTableDialogOpen.value = false;
+    await connectionStore.loadTables(props.connectionId, props.namespace);
+    queryStore.closeTab(props.tabId);
+    toast(t("hbase.tableDeleted", { table: qualifiedTableLabel.value }));
+  } catch (caught) {
+    deleteTableError.value = errorMessage(caught);
+  } finally {
+    deleteTableLoading.value = false;
+  }
+}
+
+async function saveGridChanges(changes: { dirtyRows: Map<number, Map<number, CellValue>>; deletedRows: Set<number>; columns: string[] }) {
+  for (const [rowIndex, dirtyColumns] of changes.dirtyRows) {
+    const row = rows.value[rowIndex];
+    if (!row) continue;
+    const cells: HBaseCellInput[] = [];
+    for (const [columnIndex, value] of dirtyColumns) {
+      const column = changes.columns[columnIndex];
+      if (!column || column === "_row_key") continue;
+      cells.push(hbaseCellInput(column, value));
+    }
+    if (cells.length > 0) {
+      await api.hbasePutRow(props.connectionId, props.namespace, props.table, {
+        rowKey: row.rowKeyBase64,
+        rowKeyEncoding: "base64",
+        cells,
+      });
+    }
+  }
+  for (const rowIndex of changes.deletedRows) {
+    const row = rows.value[rowIndex];
+    if (!row) continue;
+    await api.hbaseDeleteRow(props.connectionId, props.namespace, props.table, row.rowKeyBase64, "base64");
+  }
+}
+
+async function previewGridChanges(changes: { dirtyRows: Map<number, Map<number, CellValue>>; deletedRows: Set<number>; columns: string[] }) {
+  const statements: string[] = [];
+  for (const [rowIndex, dirtyColumns] of changes.dirtyRows) {
+    const row = rows.value[rowIndex];
+    if (!row) continue;
+    const columns = Array.from(dirtyColumns.keys())
+      .map((index) => changes.columns[index])
+      .filter((column) => column && column !== "_row_key");
+    if (columns.length > 0) statements.push(`PUT ${qualifiedTableLabel.value}/${row.rowKey} (${columns.join(", ")})`);
+  }
+  for (const rowIndex of changes.deletedRows) {
+    const row = rows.value[rowIndex];
+    if (row) statements.push(`DELETE ${qualifiedTableLabel.value}/${row.rowKey}`);
+  }
+  return statements;
+}
+
+function parseWriteInput(source: string): HBasePutRowInput {
+  const value = JSON.parse(source) as { rowKey?: unknown; cells?: unknown };
+  const rowKey = encodedJsonValue(value.rowKey, "rowKey");
+  if (!value.cells || typeof value.cells !== "object" || Array.isArray(value.cells)) {
+    throw new Error(t("hbase.cellsObjectRequired"));
+  }
+  const cells = Object.entries(value.cells as Record<string, unknown>).map(([column, cellValue]) => {
+    const encoded = encodedJsonValue(cellValue, column);
+    return { column, value: encoded.value, valueEncoding: encoded.encoding };
+  });
+  if (cells.length === 0) throw new Error(t("hbase.cellRequired"));
+  return { rowKey: rowKey.value, rowKeyEncoding: rowKey.encoding, cells };
+}
+
+function encodedJsonValue(value: unknown, label: string): { value: string; encoding: HBaseValueEncoding } {
+  if (typeof value === "string") {
+    return value.startsWith("base64:") ? { value: value.slice(7), encoding: "base64" } : { value, encoding: "utf8" };
+  }
+  if (value && typeof value === "object" && !Array.isArray(value) && typeof (value as { base64?: unknown }).base64 === "string") {
+    return { value: (value as { base64: string }).base64, encoding: "base64" };
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return { value: value === null ? "" : String(value), encoding: "utf8" };
+  }
+  throw new Error(t("hbase.invalidJsonValue", { label }));
+}
+
+function errorMessage(value: unknown): string {
+  return value instanceof Error ? value.message : String(value);
+}
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex min-h-10 shrink-0 flex-wrap items-center gap-2 border-b px-2 py-1.5">
+      <div class="flex min-w-0 items-center gap-1.5 pr-1">
+        <DatabaseZap class="h-4 w-4 shrink-0 text-primary" />
+        <span class="truncate text-xs font-medium">{{ qualifiedTableLabel }}</span>
+      </div>
+
+      <div v-if="hasTable" class="flex h-7 shrink-0 items-center rounded border bg-muted/40 p-0.5">
+        <button type="button" class="flex h-6 items-center gap-1 rounded-sm px-2 text-xs transition-colors" :class="lookupMode === 'prefix' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" @click="lookupMode = 'prefix'">
+          <ListFilter class="h-3.5 w-3.5" />
+          {{ t("hbase.prefix") }}
+        </button>
+        <button type="button" class="flex h-6 items-center gap-1 rounded-sm px-2 text-xs transition-colors" :class="lookupMode === 'exact' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" @click="lookupMode = 'exact'">
+          <ScanSearch class="h-3.5 w-3.5" />
+          {{ t("hbase.exact") }}
+        </button>
+      </div>
+
+      <Input v-if="hasTable" v-model="rowKeyInput" class="h-7 min-w-40 flex-1 text-xs sm:max-w-80" :placeholder="lookupMode === 'prefix' ? t('hbase.rowKeyPrefix') : t('hbase.rowKey')" @keydown.enter="refreshRows" />
+
+      <Select v-if="hasTable && lookupMode === 'prefix'" v-model="rowLimit">
+        <SelectTrigger class="h-7 w-24 text-xs">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="50">50 {{ t("hbase.rows") }}</SelectItem>
+          <SelectItem value="100">100 {{ t("hbase.rows") }}</SelectItem>
+          <SelectItem value="200">200 {{ t("hbase.rows") }}</SelectItem>
+          <SelectItem value="500">500 {{ t("hbase.rows") }}</SelectItem>
+        </SelectContent>
+      </Select>
+
+      <Button v-if="hasTable" variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" :disabled="loading" @click="refreshRows">
+        <Loader2 v-if="loading" class="h-3.5 w-3.5 animate-spin" />
+        <RefreshCw v-else class="h-3.5 w-3.5" />
+        {{ t("grid.refresh") }}
+      </Button>
+      <Button v-if="hasTable" variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="openSchemaDialog">
+        <Braces class="h-3.5 w-3.5" />
+        {{ t("hbase.schema") }}
+      </Button>
+      <Button v-if="hasTable && !readOnly" variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" :disabled="schemaLoading" @click="openWriteDialog">
+        <Loader2 v-if="schemaLoading" class="h-3.5 w-3.5 animate-spin" />
+        <Plus v-else class="h-3.5 w-3.5" />
+        {{ t("hbase.writeRow") }}
+      </Button>
+      <Button v-if="hasTable && !readOnly" variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="openCreateTableDialog">
+        <TableProperties class="h-3.5 w-3.5" />
+        {{ t("hbase.createTable") }}
+      </Button>
+      <Button
+        v-if="hasTable && !readOnly"
+        variant="ghost"
+        size="icon-sm"
+        class="h-7 w-7 text-destructive"
+        :aria-label="t('hbase.deleteTable')"
+        @click="
+          deleteTableError = '';
+          deleteTableDialogOpen = true;
+        "
+      >
+        <Trash2 class="h-3.5 w-3.5" />
+      </Button>
+    </div>
+
+    <div v-if="hasTable" class="flex h-7 shrink-0 items-center gap-2 border-b px-3 text-[11px] text-muted-foreground">
+      <span>{{ t("hbase.loadedRows", { count: rows.length }) }}</span>
+      <span>{{ elapsedMs }} ms</span>
+      <span v-if="truncated" class="text-amber-600 dark:text-amber-400">{{ t("hbase.resultTruncated") }}</span>
+    </div>
+
+    <ErrorBanner v-if="error" :message="error" dismissible @dismiss="error = ''" />
+    <DataGrid
+      v-if="hasTable"
+      class="min-h-0 flex-1"
+      :result="gridResult"
+      context="results"
+      database-type="hbase"
+      :editable="!readOnly"
+      :custom-save-handler="customSaveHandler"
+      :allow-insert-rows="false"
+      :allow-delete-rows="!readOnly"
+      :loading="loading"
+      :page-limit="Number(rowLimit)"
+      :total-row-count="rows.length"
+      :total-row-count-is-exact="!truncated"
+      @reload="refreshRows"
+    />
+    <div v-else class="flex min-h-0 flex-1 items-center justify-center">
+      <Button v-if="!readOnly" variant="outline" class="gap-2" @click="openCreateTableDialog">
+        <TableProperties class="h-4 w-4" />
+        {{ t("hbase.createTable") }}
+      </Button>
+    </div>
+
+    <Dialog v-model:open="schemaDialogOpen">
+      <DialogContent class="max-h-[80vh] max-w-2xl overflow-hidden p-0">
+        <DialogHeader class="border-b px-4 py-3">
+          <DialogTitle class="text-sm">{{ t("hbase.tableSchema", { table: qualifiedTableLabel }) }}</DialogTitle>
+        </DialogHeader>
+        <div class="min-h-0 overflow-auto px-4 py-3">
+          <div v-if="schemaLoading" class="flex min-h-32 items-center justify-center">
+            <Loader2 class="h-5 w-5 animate-spin text-muted-foreground" />
+          </div>
+          <div v-else-if="schema" class="space-y-4 text-xs">
+            <section v-for="family in schema.columnFamilies" :key="family.name" class="border-b pb-3 last:border-b-0">
+              <div class="mb-2 font-medium">{{ family.name }}</div>
+              <dl class="grid grid-cols-[minmax(8rem,auto)_1fr] gap-x-4 gap-y-1 font-mono text-[11px]">
+                <template v-for="(value, key) in family.properties" :key="key">
+                  <dt class="text-muted-foreground">{{ key }}</dt>
+                  <dd class="break-all">{{ value }}</dd>
+                </template>
+              </dl>
+            </section>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="writeDialogOpen">
+      <DialogContent class="max-w-xl">
+        <DialogHeader>
+          <DialogTitle class="text-sm">{{ t("hbase.writeRow") }}</DialogTitle>
+        </DialogHeader>
+        <ErrorBanner v-if="writeError" :message="writeError" dismissible @dismiss="writeError = ''" />
+        <textarea v-model="writeJson" class="min-h-64 w-full resize-y rounded border bg-muted/20 p-3 font-mono text-xs outline-none focus:ring-1 focus:ring-ring" spellcheck="false" />
+        <DialogFooter>
+          <Button variant="outline" :disabled="writeLoading" @click="writeDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button :disabled="writeLoading" @click="writeRow">
+            <Loader2 v-if="writeLoading" class="mr-1.5 h-4 w-4 animate-spin" />
+            {{ t("common.save") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="createTableDialogOpen">
+      <DialogContent class="max-w-md">
+        <DialogHeader>
+          <DialogTitle class="text-sm">{{ t("hbase.createTableIn", { namespace }) }}</DialogTitle>
+        </DialogHeader>
+        <ErrorBanner v-if="createTableError" :message="createTableError" dismissible @dismiss="createTableError = ''" />
+        <div class="space-y-3">
+          <Input v-model="createTableName" :placeholder="t('hbase.tableName')" />
+          <Input v-model="createColumnFamilies" :placeholder="t('hbase.columnFamiliesPlaceholder')" @keydown.enter="createTable" />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" :disabled="createTableLoading" @click="createTableDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button :disabled="createTableLoading || !createTableName.trim() || !createColumnFamilies.trim()" @click="createTable">
+            <Loader2 v-if="createTableLoading" class="mr-1.5 h-4 w-4 animate-spin" />
+            {{ t("hbase.create") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <DangerConfirmDialog
+      v-model:open="deleteTableDialogOpen"
+      :title="t('hbase.deleteTable')"
+      :message="t('hbase.deleteTableConfirm', { table: qualifiedTableLabel })"
+      :details="qualifiedTableLabel"
+      :confirm-label="t('common.delete')"
+      :loading="deleteTableLoading"
+      :close-on-confirm="false"
+      @confirm="deleteTable"
+    >
+      <template #options>
+        <ErrorBanner v-if="deleteTableError" :message="deleteTableError" dismissible class="mb-3" @dismiss="deleteTableError = ''" />
+      </template>
+    </DangerConfirmDialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index adaf7c88fd..8e620c32c9 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -50,6 +50,7 @@ const DocumentBrowser = defineAsyncComponent(() => import("@/components/document
 const MongoGridFsBrowser = defineAsyncComponent(() => import("@/components/document/MongoGridFsBrowser.vue"));
 const MongoBucketBrowser = defineAsyncComponent(() => import("@/components/document/MongoBucketBrowser.vue"));
 const VectorBrowser = defineAsyncComponent(() => import("@/components/vector/VectorBrowser.vue"));
+const HBaseBrowser = defineAsyncComponent(() => import("@/components/hbase/HBaseBrowser.vue"));
 const ElasticsearchJsonResponsePanel = defineAsyncComponent(() => import("@/components/common/ElasticsearchJsonResponsePanel.vue"));
 const MqAdminConsole = defineAsyncComponent(() => import("@/components/mq/MqAdminConsole.vue"));
 const NacosAdminConsole = defineAsyncComponent(() => import("@/components/nacos/NacosAdminConsole.vue"));
@@ -1812,6 +1813,12 @@ defineExpose({ focusSearch, refreshData, refreshQueryEditorCompletionCache, hand
       </div>
     </template>
 
+    <template v-else-if="activeTab.mode === 'hbase'">
+      <div class="flex-1 min-h-0">
+        <HBaseBrowser :key="activeTab.id" :tab-id="activeTab.id" :connection-id="activeTab.connectionId" :namespace="activeTab.database" :table="activeTab.sql" :create-table-on-open="activeTab.hbaseCreateTableOnOpen" />
+      </div>
+    </template>
+
     <template v-else-if="activeTab.mode === 'mq'">
       <div class="flex-1 min-h-0">
         <MqAdminConsole :key="activeTab.id" :connection-id="activeTab.connectionId" :initial-tenant="activeTab.mqTenant" :initial-tab="activeTab.mqInitialTab" :read-only="activeConnection?.read_only ?? false" />
diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
index cbfc117d42..9a549d0fc6 100644
--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
@@ -2044,7 +2044,13 @@ async function confirmBatchEmpty() {
 
 const canCreateTable = computed(() => {
   const config = activeNode.value.connectionId ? connectionStore.getConfig(activeNode.value.connectionId) : undefined;
-  return (activeNode.value.type === "database" || activeNode.value.type === "schema" || activeNode.value.type === "group-tables") && !isSqlServerLinkedNode(activeNode.value) && !!activeNode.value.database && supportsTableStructureEditing(tableStructureDatabaseTypeForConnection(config));
+  const supportsHBaseTableCreation = config?.db_type === "hbase" && !config.read_only;
+  return (
+    (activeNode.value.type === "database" || activeNode.value.type === "schema" || activeNode.value.type === "group-tables") &&
+    !isSqlServerLinkedNode(activeNode.value) &&
+    !!activeNode.value.database &&
+    (supportsHBaseTableCreation || supportsTableStructureEditing(tableStructureDatabaseTypeForConnection(config)))
+  );
 });
 
 const canCreateDatabase = computed(() => {
@@ -2905,6 +2911,12 @@ function openPasteTableDialog() {
 function createTable() {
   const node = activeNode.value;
   if (!node.connectionId || !node.database) return;
+  if (connectionStore.getConfig(node.connectionId)?.db_type === "hbase") {
+    const tabId = queryStore.createTab(node.connectionId, node.database, node.database, "hbase", undefined, "");
+    const tab = queryStore.tabs.find((candidate) => candidate.id === tabId);
+    if (tab) tab.hbaseCreateTableOnOpen = true;
+    return;
+  }
   queryStore.openTableStructure(node.connectionId, node.database, node.schema, "");
 }
 
@@ -3694,6 +3706,20 @@ function buildDatabaseSidebarMenu(context: SidebarMenuFactoryContext): boolean {
   const { node, items } = context;
   // 4. Database / Schema
   if (node.type === "database" || node.type === "schema") {
+    if (currentDatabaseType() === "hbase") {
+      items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+      if (canCreateTable.value) {
+        items.push({ label: "", separator: true });
+        items.push({ label: t("contextMenu.createTable"), action: createTable, icon: Plus });
+      }
+      items.push({
+        label: t("contextMenu.refreshChildren"),
+        action: refresh,
+        icon: RefreshCw,
+        shortcut: shortcutRefresh,
+      });
+      return true;
+    }
     if (canCloseDatabaseConnection.value) {
       items.push({ label: t("contextMenu.closeDatabaseConnection"), action: closeDatabaseConnection, icon: Unplug });
       items.push({ label: "", separator: true });
@@ -3703,9 +3729,11 @@ function buildDatabaseSidebarMenu(context: SidebarMenuFactoryContext): boolean {
     if (canOpenObjectBrowser.value) {
       items.push({ label: t("contextMenu.openObjectBrowser"), action: openObjectBrowser, icon: TableProperties });
     }
-    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
-    const sqlHistoryMenu = savedSqlHistorySubmenu();
-    if (sqlHistoryMenu) items.push(sqlHistoryMenu);
+    if (supportsConnectionQueryActions(currentDatabaseType())) {
+      items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+      const sqlHistoryMenu = savedSqlHistorySubmenu();
+      if (sqlHistoryMenu) items.push(sqlHistoryMenu);
+    }
     if (node.type === "database" && currentDatabaseType() !== "cloudflare-d1") {
       if (!isNodeDefaultDatabase.value) {
         items.push({ label: t("contextMenu.setDefaultDatabase"), action: setNodeAsDefaultDatabase, icon: Database });
@@ -3789,6 +3817,40 @@ function buildDatabaseSidebarMenu(context: SidebarMenuFactoryContext): boolean {
 function buildSpecialSidebarMenu(context: SidebarMenuFactoryContext): boolean {
   const { node, items } = context;
   // 5. Redis DB / Mongo DB
+  if (currentDatabaseType() === "hbase" && node.type === "group-tables") {
+    if (canCreateTable.value) {
+      items.push({ label: t("contextMenu.createTable"), action: createTable, icon: Plus });
+      items.push({ label: "", separator: true });
+    }
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    return true;
+  }
+
+  if (currentDatabaseType() === "hbase" && node.type === "table") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.viewData"), action: openDataImmediately, icon: TableProperties });
+    items.push({
+      label: t("contextMenu.openInNewDataTab"),
+      action: openDataInNewTabImmediately,
+      icon: CopyPlus,
+      shortcut: shortcutOpenDataInNewTab.value,
+    });
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    return true;
+  }
+
   if (node.type === "etcd-root" || node.type === "etcd-dashboard" || node.type === "zookeeper-root") {
     items.push({ label: t("contextMenu.openConnection"), action: toggle, icon: Database });
     return true;
diff --git a/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts b/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
index 93ae5a3f70..212c313e4f 100644
--- a/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
+++ b/apps/desktop/src/composables/useSidebarDataOpenRuntime.ts
@@ -30,6 +30,12 @@ export function useSidebarDataOpenRuntime() {
   async function openData(node: TreeNode, request?: SidebarDataOpenRequest, openMode: DataTabOpenMode = "default") {
     if (!(node.type === "table" || node.type === "view" || node.type === "materialized_view") || !hasNodeDatabaseContext(node)) return;
     const config = connectionStore.getConfig(node.connectionId);
+    if (config?.db_type === "hbase") {
+      await connectionStore.ensureConnected(node.connectionId);
+      const tabId = queryStore.createTab(node.connectionId, node.database, node.label, "hbase", undefined, node.label, undefined, { forceNew: openMode === "new-tab" });
+      queryStore.updateSql(tabId, node.label);
+      return;
+    }
     const traceId = uuid().slice(0, 8);
     const startedAt = performance.now();
     let lastPhaseAt = startedAt;
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index c1a3f18d62..5a2a4b098f 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3124,6 +3124,32 @@ export default {
     vectorLabel: "Vector",
     vectorDimensionRequired: "Collection dimensions are not available yet. Enter a vector matching the collection dimension.",
   },
+  hbase: {
+    prefix: "Prefix",
+    exact: "Exact",
+    rowKeyPrefix: "Row key prefix",
+    rowKey: "Row key",
+    rows: "rows",
+    schema: "Schema",
+    writeRow: "Write row",
+    loadedRows: "{count} rows loaded",
+    resultTruncated: "More rows are available",
+    tableSchema: "Schema: {table}",
+    rowSaved: "HBase row saved",
+    cellsObjectRequired: "cells must be a JSON object",
+    cellRequired: "At least one cell is required",
+    noColumnFamilies: "This HBase table has no column families",
+    invalidJsonValue: "Invalid value for {label}; use text, a primitive, or base64:...",
+    createTable: "Create table",
+    create: "Create",
+    tableCreated: "HBase table {table} created",
+    tableDeleted: "HBase table {table} deleted",
+    createTableIn: "Create table in {namespace}",
+    tableName: "Table name",
+    columnFamiliesPlaceholder: "Column families, comma-separated",
+    deleteTable: "Delete table",
+    deleteTableConfirm: "Delete HBase table {table}? All rows will be permanently removed.",
+  },
   history: {
     title: "History",
     search: "Search history...",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index d3244a528b..bd04e8d0f2 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -2981,6 +2981,32 @@ export default withEnglishFallback({
     vectorLabel: "Vector",
     vectorDimensionRequired: "La dimensión de la colección aún no está disponible. Introduce un vector con la dimensión correcta.",
   },
+  hbase: {
+    prefix: "Prefijo",
+    exact: "Exacta",
+    rowKeyPrefix: "Prefijo de clave de fila",
+    rowKey: "Clave de fila",
+    rows: "filas",
+    schema: "Esquema",
+    writeRow: "Escribir fila",
+    loadedRows: "{count} filas cargadas",
+    resultTruncated: "Hay más filas disponibles",
+    tableSchema: "Esquema: {table}",
+    rowSaved: "Fila de HBase guardada",
+    cellsObjectRequired: "cells debe ser un objeto JSON",
+    cellRequired: "Se requiere al menos una celda",
+    noColumnFamilies: "Esta tabla HBase no tiene familias de columnas",
+    invalidJsonValue: "Valor no válido para {label}; usa texto, un valor primitivo o base64:...",
+    createTable: "Crear tabla",
+    create: "Crear",
+    tableCreated: "Tabla HBase {table} creada",
+    tableDeleted: "Tabla HBase {table} eliminada",
+    createTableIn: "Crear tabla en {namespace}",
+    tableName: "Nombre de tabla",
+    columnFamiliesPlaceholder: "Familias de columnas, separadas por comas",
+    deleteTable: "Eliminar tabla",
+    deleteTableConfirm: "¿Eliminar la tabla HBase {table}? Todas las filas se eliminarán permanentemente.",
+  },
   history: {
     title: "Historial",
     search: "Buscar en historial...",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index bc7b448e76..40b8c5c50f 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -2979,6 +2979,32 @@ export default withEnglishFallback({
     vectorLabel: "Vettore",
     vectorDimensionRequired: "La dimensione della collezione non è ancora disponibile. Inserisci un vettore con la dimensione corretta.",
   },
+  hbase: {
+    prefix: "Prefisso",
+    exact: "Esatta",
+    rowKeyPrefix: "Prefisso chiave riga",
+    rowKey: "Chiave riga",
+    rows: "righe",
+    schema: "Schema",
+    writeRow: "Scrivi riga",
+    loadedRows: "{count} righe caricate",
+    resultTruncated: "Sono disponibili altre righe",
+    tableSchema: "Schema: {table}",
+    rowSaved: "Riga HBase salvata",
+    cellsObjectRequired: "cells deve essere un oggetto JSON",
+    cellRequired: "È richiesta almeno una cella",
+    noColumnFamilies: "Questa tabella HBase non ha famiglie di colonne",
+    invalidJsonValue: "Valore non valido per {label}; usa testo, un valore primitivo o base64:...",
+    createTable: "Crea tabella",
+    create: "Crea",
+    tableCreated: "Tabella HBase {table} creata",
+    tableDeleted: "Tabella HBase {table} eliminata",
+    createTableIn: "Crea tabella in {namespace}",
+    tableName: "Nome tabella",
+    columnFamiliesPlaceholder: "Famiglie di colonne, separate da virgole",
+    deleteTable: "Elimina tabella",
+    deleteTableConfirm: "Eliminare la tabella HBase {table}? Tutte le righe verranno eliminate definitivamente.",
+  },
   history: {
     title: "Cronologia",
     search: "Cerca nella cronologia...",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 9d5e4e8d5f..e319e74e7b 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -2980,6 +2980,32 @@ export default withEnglishFallback({
     vectorLabel: "ベクトル",
     vectorDimensionRequired: "コレクションの次元をまだ取得できません。次元が一致するベクトルを入力してください。",
   },
+  hbase: {
+    prefix: "プレフィックス",
+    exact: "完全一致",
+    rowKeyPrefix: "行キープレフィックス",
+    rowKey: "行キー",
+    rows: "行",
+    schema: "スキーマ",
+    writeRow: "行を書き込む",
+    loadedRows: "{count} 行を読み込みました",
+    resultTruncated: "さらに行があります",
+    tableSchema: "スキーマ: {table}",
+    rowSaved: "HBase 行を保存しました",
+    cellsObjectRequired: "cells は JSON オブジェクトである必要があります",
+    cellRequired: "少なくとも 1 つのセルが必要です",
+    noColumnFamilies: "この HBase テーブルには列ファミリーがありません",
+    invalidJsonValue: "{label} の値が無効です。テキスト、プリミティブ値、または base64:... を使用してください",
+    createTable: "テーブルを作成",
+    create: "作成",
+    tableCreated: "HBase テーブル {table} を作成しました",
+    tableDeleted: "HBase テーブル {table} を削除しました",
+    createTableIn: "{namespace} にテーブルを作成",
+    tableName: "テーブル名",
+    columnFamiliesPlaceholder: "列ファミリー（カンマ区切り）",
+    deleteTable: "テーブルを削除",
+    deleteTableConfirm: "HBase テーブル {table} を削除しますか？すべての行が完全に削除されます。",
+  },
   history: {
     title: "履歴",
     search: "履歴を検索...",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index ad53d24f0b..aec68dbe0e 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -2981,6 +2981,32 @@ export default withEnglishFallback({
     vectorLabel: "Vetor",
     vectorDimensionRequired: "A dimensão da coleção ainda não está disponível. Insira um vetor com a dimensão correta.",
   },
+  hbase: {
+    prefix: "Prefixo",
+    exact: "Exata",
+    rowKeyPrefix: "Prefixo da chave da linha",
+    rowKey: "Chave da linha",
+    rows: "linhas",
+    schema: "Esquema",
+    writeRow: "Gravar linha",
+    loadedRows: "{count} linhas carregadas",
+    resultTruncated: "Há mais linhas disponíveis",
+    tableSchema: "Esquema: {table}",
+    rowSaved: "Linha do HBase salva",
+    cellsObjectRequired: "cells deve ser um objeto JSON",
+    cellRequired: "É necessária pelo menos uma célula",
+    noColumnFamilies: "Esta tabela HBase não possui famílias de colunas",
+    invalidJsonValue: "Valor inválido para {label}; use texto, um valor primitivo ou base64:...",
+    createTable: "Criar tabela",
+    create: "Criar",
+    tableCreated: "Tabela HBase {table} criada",
+    tableDeleted: "Tabela HBase {table} excluída",
+    createTableIn: "Criar tabela em {namespace}",
+    tableName: "Nome da tabela",
+    columnFamiliesPlaceholder: "Famílias de colunas, separadas por vírgulas",
+    deleteTable: "Excluir tabela",
+    deleteTableConfirm: "Excluir a tabela HBase {table}? Todas as linhas serão removidas permanentemente.",
+  },
   history: {
     title: "Histórico",
     search: "Pesquisar histórico...",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 9e70f69332..3a98353a2a 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3124,6 +3124,32 @@ export default withEnglishFallback({
     vectorLabel: "向量",
     vectorDimensionRequired: "暂未获取到集合维度，请先输入与集合维度一致的向量。",
   },
+  hbase: {
+    prefix: "前缀",
+    exact: "精确",
+    rowKeyPrefix: "Row Key 前缀",
+    rowKey: "Row Key",
+    rows: "行",
+    schema: "Schema",
+    writeRow: "写入行",
+    loadedRows: "已加载 {count} 行",
+    resultTruncated: "仍有更多数据",
+    tableSchema: "Schema：{table}",
+    rowSaved: "HBase 行已保存",
+    cellsObjectRequired: "cells 必须是 JSON 对象",
+    cellRequired: "至少需要一个单元格",
+    noColumnFamilies: "当前 HBase 表没有列族",
+    invalidJsonValue: "{label} 的值无效，请使用文本、基础类型或 base64:...",
+    createTable: "新建表",
+    create: "创建",
+    tableCreated: "HBase 表 {table} 已创建",
+    tableDeleted: "HBase 表 {table} 已删除",
+    createTableIn: "在 {namespace} 中新建表",
+    tableName: "表名",
+    columnFamiliesPlaceholder: "列族，使用逗号分隔",
+    deleteTable: "删除表",
+    deleteTableConfirm: "确定删除 HBase 表 {table} 吗？其中所有行都会被永久删除。",
+  },
   history: {
     title: "历史",
     search: "搜索历史...",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index c9a1a3766d..61472606d3 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -2652,6 +2652,32 @@ export default withEnglishFallback({
     vectorLabel: "向量",
     vectorDimensionRequired: "尚未取得集合維度，請先輸入與集合維度一致的向量。",
   },
+  hbase: {
+    prefix: "前綴",
+    exact: "精確",
+    rowKeyPrefix: "Row Key 前綴",
+    rowKey: "Row Key",
+    rows: "列",
+    schema: "Schema",
+    writeRow: "寫入資料列",
+    loadedRows: "已載入 {count} 列",
+    resultTruncated: "仍有更多資料",
+    tableSchema: "Schema：{table}",
+    rowSaved: "HBase 資料列已儲存",
+    cellsObjectRequired: "cells 必須是 JSON 物件",
+    cellRequired: "至少需要一個儲存格",
+    noColumnFamilies: "目前 HBase 資料表沒有欄族",
+    invalidJsonValue: "{label} 的值無效，請使用文字、基本型別或 base64:...",
+    createTable: "建立資料表",
+    create: "建立",
+    tableCreated: "HBase 資料表 {table} 已建立",
+    tableDeleted: "HBase 資料表 {table} 已刪除",
+    createTableIn: "在 {namespace} 中建立資料表",
+    tableName: "資料表名稱",
+    columnFamiliesPlaceholder: "欄族，以逗號分隔",
+    deleteTable: "刪除資料表",
+    deleteTableConfirm: "確定要刪除 HBase 資料表 {table} 嗎？其中所有資料列都會永久刪除。",
+  },
   history: {
     title: "歷史",
     search: "搜尋歷史……",
diff --git a/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts
index 340f27177c..4af23bbee7 100644
--- a/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts
+++ b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts
@@ -98,6 +98,7 @@ describe("database property editing", () => {
     expect(editableDatabasePropertyGroups({ db_type: "mysql", read_only: true }, { type: "database", database: "app" })).toEqual([]);
     expect(editableDatabasePropertyGroups({ db_type: "sqlite" }, { type: "database", database: "main" })).toEqual([]);
     expect(editableDatabasePropertyGroups({ db_type: "sqlserver" }, { type: "database", database: "master" })).toEqual([]);
+    expect(editableDatabasePropertyGroups({ db_type: "hbase" }, { type: "database", database: "default" })).toEqual([]);
     expect(editableDatabasePropertyGroups({ db_type: "postgres" }, { type: "connection" })).toEqual([]);
     expect(editableSchemaPropertyGroups({ db_type: "postgres", read_only: true }, { type: "schema", database: "postgres", schema: "public" })).toEqual([]);
     expect(editableSchemaPropertyGroups({ db_type: "postgres" }, { type: "database", database: "postgres" })).toEqual([]);
@@ -137,6 +138,7 @@ describe("database namespace creation", () => {
     expect(connectionNamespaceCreationTarget({ db_type: "sqlite", read_only: true })).toBeNull();
     expect(connectionNamespaceCreationTarget({ db_type: "jdbc" })).toBeNull();
     expect(connectionNamespaceCreationTarget({ db_type: "oracle" })).toBeNull();
+    expect(connectionNamespaceCreationTarget({ db_type: "hbase" })).toBeNull();
   });
 
   it("allows schema creation only on writable database nodes with schema targets", () => {
diff --git a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
index f9c7a78cbb..b3d54b8d0d 100644
--- a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
+++ b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
@@ -6,6 +6,10 @@ describe("databaseObjectCapabilities", () => {
     expect(sidebarObjectKindsForDatabase("dameng")).toContain("MATERIALIZED_VIEW");
   });
 
+  it("exposes only tables for HBase namespaces", () => {
+    expect(sidebarObjectKindsForDatabase("hbase")).toEqual(["TABLE"]);
+  });
+
   it("exposes materialized views for StarRocks only", () => {
     // StarRocks has a dedicated MV listing/classification path in
     // crates/dbx-core/src/db/mysql.rs (`list_starrocks_tables` +
diff --git a/apps/desktop/src/lib/__tests__/hbase/hbaseValues.spec.ts b/apps/desktop/src/lib/__tests__/hbase/hbaseValues.spec.ts
new file mode 100644
index 0000000000..936dd02912
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/hbase/hbaseValues.spec.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+
+import { encodeHBaseTextInput, hbaseCellInput } from "@/lib/hbase/hbaseValues";
+
+describe("HBase value conversion", () => {
+  it("keeps UTF-8 input unchanged", () => {
+    expect(encodeHBaseTextInput("customer#001")).toEqual({ value: "customer#001", encoding: "utf8" });
+    expect(hbaseCellInput("profile:name", "Alice")).toEqual({
+      column: "profile:name",
+      value: "Alice",
+      valueEncoding: "utf8",
+    });
+  });
+
+  it("removes the display prefix before sending Base64 input", () => {
+    expect(encodeHBaseTextInput("base64:AAEC")).toEqual({ value: "AAEC", encoding: "base64" });
+    expect(hbaseCellInput("profile:avatar", "base64:AP8=")).toEqual({
+      column: "profile:avatar",
+      value: "AP8=",
+      valueEncoding: "base64",
+    });
+  });
+
+  it("writes null cells as empty UTF-8 values", () => {
+    expect(hbaseCellInput("profile:note", null)).toEqual({
+      column: "profile:note",
+      value: "",
+      valueEncoding: "utf8",
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index 72600987bb..3c825c6c15 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -424,6 +424,15 @@ export const zookeeperGet = forward("zookeeperGet");
 export const zookeeperPut = forward("zookeeperPut");
 export const zookeeperDelete = forward("zookeeperDelete");
 
+// HBase
+export const hbaseGetTableSchema = forward("hbaseGetTableSchema");
+export const hbaseScanRows = forward("hbaseScanRows");
+export const hbaseGetRow = forward("hbaseGetRow");
+export const hbasePutRow = forward("hbasePutRow");
+export const hbaseDeleteRow = forward("hbaseDeleteRow");
+export const hbaseCreateTable = forward("hbaseCreateTable");
+export const hbaseDeleteTable = forward("hbaseDeleteTable");
+
 // Message Queue
 export const mqTestConnection = forward("mqTestConnection");
 export const mqListTenants = forward("mqListTenants");
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index a97e14c2d6..77bbfded50 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -2295,6 +2295,38 @@ export async function nacosRawRequest(connectionId: string, req: NacosRawRequest
   return post("/api/nacos/raw", { connectionId, req });
 }
 
+// ---------------------------------------------------------------------------
+// HBase
+// ---------------------------------------------------------------------------
+
+export async function hbaseGetTableSchema(connectionId: string, namespace: string, table: string): Promise<import("@/types/hbase").HBaseTableSchema> {
+  return post("/api/hbase/table-schema", { connectionId, namespace, table });
+}
+
+export async function hbaseScanRows(connectionId: string, namespace: string, table: string, rowKeyPrefix: string | undefined, limit: number): Promise<import("@/types/hbase").HBaseScanResult> {
+  return post("/api/hbase/scan-rows", { connectionId, namespace, table, rowKeyPrefix, limit });
+}
+
+export async function hbaseGetRow(connectionId: string, namespace: string, table: string, rowKey: string, rowKeyEncoding?: import("@/types/hbase").HBaseValueEncoding): Promise<import("@/types/hbase").HBaseRow | null> {
+  return post("/api/hbase/get-row", { connectionId, namespace, table, rowKey, rowKeyEncoding });
+}
+
+export async function hbasePutRow(connectionId: string, namespace: string, table: string, input: import("@/types/hbase").HBasePutRowInput): Promise<void> {
+  return post("/api/hbase/put-row", { connectionId, namespace, table, input });
+}
+
+export async function hbaseDeleteRow(connectionId: string, namespace: string, table: string, rowKey: string, rowKeyEncoding?: import("@/types/hbase").HBaseValueEncoding): Promise<void> {
+  return post("/api/hbase/delete-row", { connectionId, namespace, table, rowKey, rowKeyEncoding });
+}
+
+export async function hbaseCreateTable(connectionId: string, namespace: string, table: string, columnFamilies: string[]): Promise<void> {
+  return post("/api/hbase/create-table", { connectionId, namespace, table, columnFamilies });
+}
+
+export async function hbaseDeleteTable(connectionId: string, namespace: string, table: string): Promise<void> {
+  return post("/api/hbase/delete-table", { connectionId, namespace, table });
+}
+
 // ---------------------------------------------------------------------------
 // MongoDB
 // ---------------------------------------------------------------------------
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 3e95464bc5..acaa4361ba 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -2062,6 +2062,35 @@ export async function zookeeperDelete(connectionId: string, key: string): Promis
   return invoke("zookeeper_delete", { connectionId, key });
 }
 
+// --- HBase ---
+export async function hbaseGetTableSchema(connectionId: string, namespace: string, table: string): Promise<import("@/types/hbase").HBaseTableSchema> {
+  return invoke("hbase_get_table_schema", { connectionId, namespace, table });
+}
+
+export async function hbaseScanRows(connectionId: string, namespace: string, table: string, rowKeyPrefix: string | undefined, limit: number): Promise<import("@/types/hbase").HBaseScanResult> {
+  return invoke("hbase_scan_rows", { connectionId, namespace, table, rowKeyPrefix, limit });
+}
+
+export async function hbaseGetRow(connectionId: string, namespace: string, table: string, rowKey: string, rowKeyEncoding?: import("@/types/hbase").HBaseValueEncoding): Promise<import("@/types/hbase").HBaseRow | null> {
+  return invoke("hbase_get_row", { connectionId, namespace, table, rowKey, rowKeyEncoding });
+}
+
+export async function hbasePutRow(connectionId: string, namespace: string, table: string, input: import("@/types/hbase").HBasePutRowInput): Promise<void> {
+  return invoke("hbase_put_row", { connectionId, namespace, table, input });
+}
+
+export async function hbaseDeleteRow(connectionId: string, namespace: string, table: string, rowKey: string, rowKeyEncoding?: import("@/types/hbase").HBaseValueEncoding): Promise<void> {
+  return invoke("hbase_delete_row", { connectionId, namespace, table, rowKey, rowKeyEncoding });
+}
+
+export async function hbaseCreateTable(connectionId: string, namespace: string, table: string, columnFamilies: string[]): Promise<void> {
+  return invoke("hbase_create_table", { connectionId, namespace, table, columnFamilies });
+}
+
+export async function hbaseDeleteTable(connectionId: string, namespace: string, table: string): Promise<void> {
+  return invoke("hbase_delete_table", { connectionId, namespace, table });
+}
+
 // --- Document stores ---
 export interface DocumentQueryResult {
   documents: any[];
diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.ts
index ff763dcf14..df4811bae4 100644
--- a/apps/desktop/src/lib/database/databaseFeatureSupport.ts
+++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts
@@ -74,7 +74,7 @@ export function supportsClearableQuerySchema(dbType?: DatabaseType): boolean {
 }
 
 export function supportsConnectionQueryActions(dbType?: DatabaseType): boolean {
-  return dbType !== "nacos";
+  return dbType !== "nacos" && dbType !== "hbase";
 }
 
 export function usesFetchFirst(dbType?: DatabaseType): boolean {
diff --git a/apps/desktop/src/lib/database/databaseNamespaceCreation.ts b/apps/desktop/src/lib/database/databaseNamespaceCreation.ts
index 97186571c5..85237daee2 100644
--- a/apps/desktop/src/lib/database/databaseNamespaceCreation.ts
+++ b/apps/desktop/src/lib/database/databaseNamespaceCreation.ts
@@ -28,6 +28,7 @@ export const DATABASE_NAMESPACE_CREATION_MATRIX = {
   mongodb: { connection: "special" },
   oracle: { deferred: "Oracle schemas are users; database creation is not a normal connected DDL action" },
   elasticsearch: { deferred: "index creation is not modeled as database creation" },
+  hbase: { deferred: "namespace creation needs dedicated HBase namespace options" },
   qdrant: { deferred: "collection creation is separate from database creation" },
   milvus: { deferred: "collection/database lifecycle needs a dedicated vector workflow" },
   weaviate: { deferred: "collection creation is separate from database creation" },
diff --git a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
index bac265fa76..8d58c54325 100644
--- a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
+++ b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
@@ -61,6 +61,7 @@ const DATABASE_TYPE_OBJECTS = new Map<DatabaseType, SidebarObjectKind[]>([
   ["neo4j", TABLE_VIEW_OBJECTS],
   // others
   ["influxdb", ["TABLE"]],
+  ["hbase", ["TABLE"]],
   ["questdb", ["TABLE", "VIEW", "MATERIALIZED_VIEW"]],
   ["manticoresearch", ["TABLE", "FUNCTION"]],
   ["databend", ["TABLE", "VIEW", "PROCEDURE"]],
diff --git a/apps/desktop/src/lib/database/databasePropertyEditing.ts b/apps/desktop/src/lib/database/databasePropertyEditing.ts
index e9166cfaf1..0c359204e7 100644
--- a/apps/desktop/src/lib/database/databasePropertyEditing.ts
+++ b/apps/desktop/src/lib/database/databasePropertyEditing.ts
@@ -29,6 +29,7 @@ export const DATABASE_PROPERTY_EDITING_MATRIX = {
   mongodb: { deferred: "database options are not modeled as SQL database properties" },
   oracle: { deferred: "Oracle database properties are instance/user/tablespace administration" },
   elasticsearch: { deferred: "index settings are not database properties" },
+  hbase: { deferred: "namespace and table properties need a dedicated HBase workflow" },
   qdrant: { deferred: "collection settings are not database properties" },
   milvus: { deferred: "collection/database settings need a dedicated vector workflow" },
   weaviate: { deferred: "collection settings are not database properties" },
diff --git a/apps/desktop/src/lib/hbase/hbaseValues.ts b/apps/desktop/src/lib/hbase/hbaseValues.ts
new file mode 100644
index 0000000000..d4e63ecfc6
--- /dev/null
+++ b/apps/desktop/src/lib/hbase/hbaseValues.ts
@@ -0,0 +1,16 @@
+import type { CellValue } from "@/lib/dataGrid/cellValue";
+import type { HBaseCellInput, HBaseValueEncoding } from "@/types/hbase";
+
+export interface HBaseEncodedText {
+  value: string;
+  encoding: HBaseValueEncoding;
+}
+
+export function encodeHBaseTextInput(value: string): HBaseEncodedText {
+  return value.startsWith("base64:") ? { value: value.slice(7), encoding: "base64" } : { value, encoding: "utf8" };
+}
+
+export function hbaseCellInput(column: string, value: CellValue): HBaseCellInput {
+  const encoded = encodeHBaseTextInput(value == null ? "" : String(value));
+  return { column, value: encoded.value, valueEncoding: encoded.encoding };
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts b/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts
index da1bfb283e..2b2bf3e64f 100644
--- a/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts
+++ b/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts
@@ -26,6 +26,12 @@ export type ActiveTabSidebarTarget =
       database: string;
       collectionName: string;
     }
+  | {
+      type: "hbase-table";
+      connectionId: string;
+      namespace: string;
+      tableName: string;
+    }
   | {
       type: "etcd-root";
       connectionId: string;
@@ -112,6 +118,16 @@ export function activeTabSidebarTarget(tab: QueryTab | undefined | null): Active
     };
   }
 
+  if (tab.mode === "hbase") {
+    if (!tab.sql) return null;
+    return {
+      type: "hbase-table",
+      connectionId: tab.connectionId,
+      namespace: tab.database,
+      tableName: tab.sql || tab.title,
+    };
+  }
+
   if (tab.mode === "etcd") {
     return { type: "etcd-root", connectionId: tab.connectionId };
   }
@@ -176,6 +192,10 @@ export function matchesTarget(node: TreeNode, target: ActiveTabSidebarTarget): b
     return node.type === "vector-collection" && node.connectionId === target.connectionId && node.database === target.database && node.label === target.collectionName;
   }
 
+  if (target.type === "hbase-table") {
+    return node.type === "table" && node.connectionId === target.connectionId && node.database === target.namespace && node.label === target.tableName;
+  }
+
   if (target.type === "query-context") {
     if (target.schema) {
       return node.type === "schema" && node.connectionId === target.connectionId && node.database === target.database && node.label === target.schema;
diff --git a/apps/desktop/src/lib/table/tableMetadataCapabilities.ts b/apps/desktop/src/lib/table/tableMetadataCapabilities.ts
index 109e86b147..a7c39925db 100644
--- a/apps/desktop/src/lib/table/tableMetadataCapabilities.ts
+++ b/apps/desktop/src/lib/table/tableMetadataCapabilities.ts
@@ -31,6 +31,12 @@ const capabilityByType: Partial<Record<DatabaseType, Partial<TableMetadataCapabi
     triggers: false,
     ddl: false,
   },
+  hbase: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
   qdrant: {
     indexes: false,
     foreignKeys: false,
diff --git a/apps/desktop/src/lib/tabs/tabPresentation.ts b/apps/desktop/src/lib/tabs/tabPresentation.ts
index ab7dfb49e5..dbd635b51c 100644
--- a/apps/desktop/src/lib/tabs/tabPresentation.ts
+++ b/apps/desktop/src/lib/tabs/tabPresentation.ts
@@ -94,6 +94,10 @@ export function tabDisplayTitle(tab: QueryTab, t: Translate): string {
     if (compact) return tab.sql;
     return `${tab.sql}@${database}`;
   }
+  if (tab.mode === "hbase" && tab.sql) {
+    if (compact) return tab.sql;
+    return `${tab.sql}@${database}`;
+  }
   if (tab.mode === "redis") {
     if (compact) return connectionDisplayName(tab.connectionId);
     return `${connectionDisplayName(tab.connectionId)}@${database}`;
@@ -148,6 +152,9 @@ export function tabTooltipLines(tab: QueryTab, t: Translate): { label: string; v
   if (tab.mode === "vector" && tab.sql) {
     lines.push({ label: t("tabs.tooltipCollection"), value: tab.sql });
   }
+  if (tab.mode === "hbase" && tab.sql) {
+    lines.push({ label: t("tabs.tooltipTable"), value: tab.sql });
+  }
   if (tab.mode === "objects" && tab.objectBrowser?.schema) {
     lines.push({ label: t("tabs.tooltipSchema"), value: tab.objectBrowser.schema });
   }
@@ -333,6 +340,7 @@ export function tabModeLabel(tab: QueryTab, t: Translate): string {
   if (tab.mode === "mongo") return t("tabs.mongo");
   if (tab.mode === "mongo-gridfs" || tab.mode === "mongo-bucket") return t("tabs.gridfs");
   if (tab.mode === "vector") return t("tabs.vector");
+  if (tab.mode === "hbase") return "HBase";
   if (tab.mode === "redis") return t("tabs.redis");
   if (tab.mode === "etcd") return t("tabs.etcd");
   if (tab.mode === "etcd-dashboard") return t("tabs.etcdDashboard");
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 9a0b2e5a5c..7075720afa 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -12,6 +12,7 @@ export type DatabaseType =
   | "mongodb"
   | "oracle"
   | "elasticsearch"
+  | "hbase"
   | "qdrant"
   | "milvus"
   | "weaviate"
@@ -906,7 +907,31 @@ export interface QueryTab {
   explainClientSessionId?: string;
   /** Invalidates tab-scoped completion metadata after session context changes. */
   completionContextVersion?: number;
-  mode: "data" | "query" | "redis" | "redis-dashboard" | "mongo" | "mongo-gridfs" | "mongo-bucket" | "vector" | "etcd" | "etcd-dashboard" | "zookeeper" | "mq" | "nacos" | "nacos-dashboard" | "objects" | "structure" | "users" | "dameng-jobs" | "processlist" | "mysql-dashboard" | "postgres-dashboard";
+  mode:
+    | "data"
+    | "query"
+    | "redis"
+    | "redis-dashboard"
+    | "mongo"
+    | "mongo-gridfs"
+    | "mongo-bucket"
+    | "vector"
+    | "hbase"
+    | "etcd"
+    | "etcd-dashboard"
+    | "zookeeper"
+    | "mq"
+    | "nacos"
+    | "nacos-dashboard"
+    | "objects"
+    | "structure"
+    | "users"
+    | "dameng-jobs"
+    | "processlist"
+    | "mysql-dashboard"
+    | "postgres-dashboard";
+  /** Ephemeral navigation intent; it is consumed by HBaseBrowser and is not persisted. */
+  hbaseCreateTableOnOpen?: boolean;
   mqTenant?: string;
   mqInitialTab?: "topics";
   nacosNamespace?: string;
diff --git a/apps/desktop/src/types/hbase.ts b/apps/desktop/src/types/hbase.ts
new file mode 100644
index 0000000000..0cdad76002
--- /dev/null
+++ b/apps/desktop/src/types/hbase.ts
@@ -0,0 +1,44 @@
+export type HBaseValueEncoding = "utf8" | "base64";
+
+export interface HBaseColumnFamily {
+  name: string;
+  properties: Record<string, string>;
+}
+
+export interface HBaseTableSchema {
+  name: string;
+  columnFamilies: HBaseColumnFamily[];
+  properties: Record<string, string>;
+}
+
+export interface HBaseCell {
+  column: string;
+  value: string;
+  valueEncoding: HBaseValueEncoding;
+  valueBase64: string;
+  timestamp?: number;
+}
+
+export interface HBaseRow {
+  rowKey: string;
+  rowKeyEncoding: HBaseValueEncoding;
+  rowKeyBase64: string;
+  cells: HBaseCell[];
+}
+
+export interface HBaseScanResult {
+  rows: HBaseRow[];
+  truncated: boolean;
+}
+
+export interface HBaseCellInput {
+  column: string;
+  value: string;
+  valueEncoding?: HBaseValueEncoding;
+}
+
+export interface HBasePutRowInput {
+  rowKey: string;
+  rowKeyEncoding?: HBaseValueEncoding;
+  cells: HBaseCellInput[];
+}
diff --git a/crates/dbx-core/assets/database-drivers.manifest.json b/crates/dbx-core/assets/database-drivers.manifest.json
index 818fe9b4dc..6d4ae2c19a 100644
--- a/crates/dbx-core/assets/database-drivers.manifest.json
+++ b/crates/dbx-core/assets/database-drivers.manifest.json
@@ -355,6 +355,35 @@
         "driverManagement": false
       }
     },
+    {
+      "dbType": "hbase",
+      "label": "Apache HBase",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8080,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": false,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
     {
       "dbType": "qdrant",
       "label": "Qdrant",
diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rs
index 99b6052846..00907ed723 100644
--- a/crates/dbx-core/src/connection.rs
+++ b/crates/dbx-core/src/connection.rs
@@ -96,6 +96,7 @@ pub enum PoolKind {
     ClickHouse(db::clickhouse_driver::ChClient),
     SqlServer(Arc<tokio::sync::Mutex<db::sqlserver::SqlServerClient>>),
     Elasticsearch(db::elasticsearch_driver::EsClient),
+    HBase(db::hbase_driver::HBaseClient),
     VectorDb(db::vector_driver::VectorClient),
     InfluxDb(db::influxdb_driver::InfluxdbClient),
     Agent(Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>),
@@ -116,6 +117,7 @@ enum ConnectionDatabaseInfoSource {
     Agent(Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>),
     ExternalDriver { config: Arc<ConnectionConfig>, session: Arc<PluginDriverSession> },
     NativeMysql(db::mysql::MySqlPool),
+    NativeHBase(db::hbase_driver::HBaseClient),
 }
 
 /// Held connection for a manual transaction session
@@ -1396,6 +1398,17 @@ impl AppState {
                 db::elasticsearch_driver::test_connection(&mut client, connect_timeout).await?;
                 PoolKind::Elasticsearch(client)
             }
+            DatabaseType::Hbase => {
+                let client = db::hbase_driver::HBaseClient::new(
+                    &url,
+                    Some(&db_config.username),
+                    Some(&db_config.password),
+                    false,
+                    connect_timeout,
+                )?;
+                db::hbase_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::HBase(client)
+            }
             DatabaseType::Qdrant | DatabaseType::Milvus | DatabaseType::Weaviate | DatabaseType::ChromaDb => {
                 let kind = match db_config.db_type {
                     DatabaseType::Qdrant => db::vector_driver::VectorDbKind::Qdrant,
@@ -2225,6 +2238,18 @@ impl AppState {
                         }
                     }
                 }
+                PoolKind::HBase(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::hbase_driver::test_connection(&client, timeout).await {
+                        Ok(_) => false,
+                        Err(err) => {
+                            log::warn!("HBase connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
                 PoolKind::VectorDb(client) => {
                     let client = client.clone();
                     drop(connections);
@@ -2789,6 +2814,7 @@ impl AppState {
                     })
                 }
                 Some(PoolKind::Mysql(pool, _)) => Some(ConnectionDatabaseInfoSource::NativeMysql(pool.clone())),
+                Some(PoolKind::HBase(client)) => Some(ConnectionDatabaseInfoSource::NativeHBase(client.clone())),
                 _ => None,
             }
         };
@@ -2811,6 +2837,9 @@ impl AppState {
             Some(ConnectionDatabaseInfoSource::NativeMysql(pool)) => {
                 db::mysql::database_connection_info(&pool, db::mysql::protocol_product_name(&config)).await.map(Some)
             }
+            Some(ConnectionDatabaseInfoSource::NativeHBase(client)) => {
+                db::hbase_driver::database_connection_info(&client).await
+            }
             None => Ok(None),
         }
     }
@@ -2985,6 +3014,13 @@ impl AppState {
                         }
                     }
                 }
+                PoolKind::HBase(client) => match db::hbase_driver::test_connection(client, timeout).await {
+                    Ok(_) => true,
+                    Err(e) => {
+                        log::warn!("HBase connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
                 PoolKind::VectorDb(client) => match db::vector_driver::test_connection(client, timeout).await {
                     Ok(()) => true,
                     Err(e) => {
@@ -3226,6 +3262,7 @@ enum KeepaliveTarget {
     ClickHouse(db::clickhouse_driver::ChClient),
     SqlServer(Arc<tokio::sync::Mutex<db::sqlserver::SqlServerClient>>),
     Elasticsearch(db::elasticsearch_driver::EsClient),
+    HBase(db::hbase_driver::HBaseClient),
     VectorDb(db::vector_driver::VectorClient),
     InfluxDb(db::influxdb_driver::InfluxdbClient),
     Agent(Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>),
@@ -3244,6 +3281,7 @@ fn keepalive_target_from_pool(pool: &PoolKind, config: &ConnectionConfig) -> Opt
         PoolKind::ClickHouse(client) => Some(KeepaliveTarget::ClickHouse(client.clone())),
         PoolKind::SqlServer(client) => Some(KeepaliveTarget::SqlServer(client.clone())),
         PoolKind::Elasticsearch(client) => Some(KeepaliveTarget::Elasticsearch(client.clone())),
+        PoolKind::HBase(client) => Some(KeepaliveTarget::HBase(client.clone())),
         PoolKind::VectorDb(client) => Some(KeepaliveTarget::VectorDb(client.clone())),
         PoolKind::InfluxDb(client) => Some(KeepaliveTarget::InfluxDb(client.clone())),
         PoolKind::Agent(client) => Some(KeepaliveTarget::Agent(client.clone())),
@@ -3274,6 +3312,7 @@ async fn ping_keepalive_target(target: &mut KeepaliveTarget, timeout: Duration)
             db::sqlserver::test_connection(&mut client).await
         }
         KeepaliveTarget::Elasticsearch(client) => db::elasticsearch_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::HBase(client) => db::hbase_driver::test_connection(client, timeout).await.map(|_| ()),
         KeepaliveTarget::VectorDb(client) => db::vector_driver::test_connection(client, timeout).await,
         KeepaliveTarget::InfluxDb(client) => db::influxdb_driver::test_connection(client, timeout).await,
         KeepaliveTarget::Agent(client) => {
@@ -3466,6 +3505,7 @@ fn clone_pool_kind(pool: &PoolKind) -> PoolKind {
         PoolKind::ClickHouse(client) => PoolKind::ClickHouse(client.clone()),
         PoolKind::SqlServer(client) => PoolKind::SqlServer(client.clone()),
         PoolKind::Elasticsearch(client) => PoolKind::Elasticsearch(client.clone()),
+        PoolKind::HBase(client) => PoolKind::HBase(client.clone()),
         PoolKind::VectorDb(client) => PoolKind::VectorDb(client.clone()),
         PoolKind::InfluxDb(client) => PoolKind::InfluxDb(client.clone()),
         PoolKind::Agent(client) => PoolKind::Agent(client.clone()),
@@ -3519,6 +3559,9 @@ pub async fn close_pool_kind(pool: PoolKind) {
         PoolKind::Elasticsearch(client) => {
             drop(client);
         }
+        PoolKind::HBase(client) => {
+            drop(client);
+        }
         PoolKind::VectorDb(client) => {
             drop(client);
         }
diff --git a/crates/dbx-core/src/database_capabilities.rs b/crates/dbx-core/src/database_capabilities.rs
index b64d88d7b8..e5d2a5b187 100644
--- a/crates/dbx-core/src/database_capabilities.rs
+++ b/crates/dbx-core/src/database_capabilities.rs
@@ -18,6 +18,7 @@ pub fn is_single_connection_pool(db_type: &DatabaseType) -> bool {
             | DatabaseType::Turso
             | DatabaseType::CloudflareD1
             | DatabaseType::MongoDb
+            | DatabaseType::Hbase
             | DatabaseType::Oracle
             | DatabaseType::Dameng
             | DatabaseType::Kingbase
diff --git a/crates/dbx-core/src/db/hbase_driver.rs b/crates/dbx-core/src/db/hbase_driver.rs
new file mode 100644
index 0000000000..b7361a8e4a
--- /dev/null
+++ b/crates/dbx-core/src/db/hbase_driver.rs
@@ -0,0 +1,902 @@
+use base64::{
+    engine::general_purpose::{STANDARD as BASE64, URL_SAFE_NO_PAD as BASE64_URL},
+    Engine as _,
+};
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+use reqwest::{Client as HttpClient, RequestBuilder, Response, StatusCode};
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+use std::collections::{BTreeMap, HashMap};
+use std::time::Duration;
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::models::connection::DatabaseConnectionInfo;
+use crate::types::{ColumnInfo, DatabaseInfo, TableInfo};
+
+const PATH_SEGMENT_ENCODE_SET: &AsciiSet = &CONTROLS
+    .add(b' ')
+    .add(b'"')
+    .add(b'#')
+    .add(b'%')
+    .add(b'/')
+    .add(b'<')
+    .add(b'>')
+    .add(b'?')
+    .add(b'[')
+    .add(b'\\')
+    .add(b']')
+    .add(b'^')
+    .add(b'`')
+    .add(b'{')
+    .add(b'|')
+    .add(b'}');
+
+const HBASE_JSON: &str = "application/json";
+const HBASE_KEY_ENCODING_HEADER: &str = "Encoding";
+const HBASE_KEY_ENCODING_BASE64: &str = "base64";
+const DEFAULT_NAMESPACE: &str = "default";
+
+#[derive(Clone)]
+pub struct HBaseClient {
+    http: HttpClient,
+    base_url: String,
+    auth: Option<(String, String)>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseVersionInfo {
+    pub version: String,
+    pub rest_version: Option<String>,
+    pub server: Option<String>,
+    pub jvm: Option<String>,
+    pub os: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseColumnFamily {
+    pub name: String,
+    pub properties: BTreeMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseTableSchema {
+    pub name: String,
+    pub column_families: Vec<HBaseColumnFamily>,
+    pub properties: BTreeMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseCell {
+    pub column: String,
+    pub value: String,
+    pub value_encoding: String,
+    pub value_base64: String,
+    pub timestamp: Option<u64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseRow {
+    pub row_key: String,
+    pub row_key_encoding: String,
+    pub row_key_base64: String,
+    pub cells: Vec<HBaseCell>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseScanResult {
+    pub rows: Vec<HBaseRow>,
+    pub truncated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseCellInput {
+    pub column: String,
+    pub value: String,
+    #[serde(default)]
+    pub value_encoding: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct HBasePutRowInput {
+    pub row_key: String,
+    #[serde(default)]
+    pub row_key_encoding: Option<String>,
+    pub cells: Vec<HBaseCellInput>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestNamespaces {
+    #[serde(rename = "Namespace", default)]
+    namespaces: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestTableList {
+    #[serde(rename = "table", default)]
+    tables: Vec<RestTableName>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestTableName {
+    name: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestRows {
+    #[serde(rename = "Row", default)]
+    rows: Vec<RestRow>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestRow {
+    key: String,
+    #[serde(rename = "Cell", default)]
+    cells: Vec<RestCell>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RestCell {
+    column: String,
+    #[serde(default)]
+    timestamp: Option<u64>,
+    #[serde(rename = "$", default)]
+    value: String,
+}
+
+impl HBaseClient {
+    pub fn new(
+        url: &str,
+        username: Option<&str>,
+        password: Option<&str>,
+        accept_invalid_certs: bool,
+        timeout: Duration,
+    ) -> Result<Self, String> {
+        let base_url = url.trim().trim_end_matches('/').to_string();
+        reqwest::Url::parse(&base_url).map_err(|error| format!("Invalid HBase REST URL: {error}"))?;
+        let auth = username
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(|value| (value.to_string(), password.unwrap_or_default().to_string()));
+        let http = http_client_builder(timeout)
+            .danger_accept_invalid_certs(accept_invalid_certs)
+            .build()
+            .map_err(|error| format!("Failed to create HBase HTTP client: {error}"))?;
+        Ok(Self { http, base_url, auth })
+    }
+
+    fn request(&self, method: reqwest::Method, path: &str) -> RequestBuilder {
+        let request = self.http.request(method, format!("{}{}", self.base_url, path));
+        self.with_auth(request)
+    }
+
+    fn scanner_request(&self, method: reqwest::Method, location: &str) -> Result<RequestBuilder, String> {
+        let path = scanner_resource_path(location)?;
+        Ok(self.request(method, &path))
+    }
+
+    fn with_auth(&self, request: RequestBuilder) -> RequestBuilder {
+        match &self.auth {
+            Some((username, password)) => request.basic_auth(username, Some(password)),
+            None => request,
+        }
+    }
+}
+
+pub async fn test_connection(client: &HBaseClient, timeout: Duration) -> Result<HBaseVersionInfo, String> {
+    with_connection_timeout("HBase", timeout, async { version_info(client).await }).await
+}
+
+pub async fn version_info(client: &HBaseClient) -> Result<HBaseVersionInfo, String> {
+    let body = send_json(client.request(reqwest::Method::GET, "/version"), "read server version").await?;
+    Ok(HBaseVersionInfo {
+        version: json_string(&body, "Version").unwrap_or_else(|| "unknown".to_string()),
+        rest_version: json_string(&body, "REST"),
+        server: json_string(&body, "Server"),
+        jvm: json_string(&body, "JVM"),
+        os: json_string(&body, "OS"),
+    })
+}
+
+pub async fn database_connection_info(client: &HBaseClient) -> Result<Option<DatabaseConnectionInfo>, String> {
+    let version = version_info(client).await?;
+    Ok(Some(DatabaseConnectionInfo {
+        product_name: Some("Apache HBase".to_string()),
+        product_version: Some(version.version),
+        server_comment: version.rest_version.map(|rest| format!("HBase REST {rest}")),
+        driver_name: Some("HBase REST API".to_string()),
+        ..Default::default()
+    }))
+}
+
+pub async fn list_namespaces(client: &HBaseClient) -> Result<Vec<DatabaseInfo>, String> {
+    let response = client
+        .request(reqwest::Method::GET, "/namespaces")
+        .header(reqwest::header::ACCEPT, HBASE_JSON)
+        .send()
+        .await
+        .map_err(|error| format_request_error("list namespaces", error))?;
+    let body: RestNamespaces = parse_success_json(response, "list namespaces").await?;
+    let mut namespaces = body.namespaces;
+    namespaces.sort_by_key(|name| name.to_ascii_lowercase());
+    Ok(namespaces.into_iter().map(|name| DatabaseInfo { name }).collect())
+}
+
+pub async fn list_tables(client: &HBaseClient, namespace: &str) -> Result<Vec<TableInfo>, String> {
+    let response = client
+        .request(reqwest::Method::GET, "/")
+        .header(reqwest::header::ACCEPT, HBASE_JSON)
+        .send()
+        .await
+        .map_err(|error| format_request_error("list tables", error))?;
+    let body: RestTableList = parse_success_json(response, "list tables").await?;
+    let mut names: Vec<String> =
+        body.tables.into_iter().filter_map(|table| table_name_in_namespace(&table.name, namespace)).collect();
+    names.sort_by_key(|name| name.to_ascii_lowercase());
+    Ok(names
+        .into_iter()
+        .map(|name| TableInfo {
+            name,
+            table_type: "HBASE_TABLE".to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+pub async fn get_table_schema(client: &HBaseClient, namespace: &str, table: &str) -> Result<HBaseTableSchema, String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let path = format!("/{}/schema", path_segment(&qualified));
+    let body = send_json(client.request(reqwest::Method::GET, &path), "read table schema").await?;
+    parse_table_schema(body)
+}
+
+pub async fn get_columns(client: &HBaseClient, namespace: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let schema = get_table_schema(client, namespace, table).await?;
+    Ok(schema
+        .column_families
+        .into_iter()
+        .map(|family| ColumnInfo {
+            name: family.name,
+            data_type: "COLUMN_FAMILY".to_string(),
+            is_nullable: true,
+            extra: family.properties.get("VERSIONS").map(|versions| format!("versions={versions}")),
+            comment: family.properties.get("COMPRESSION").map(|compression| format!("compression={compression}")),
+            ..Default::default()
+        })
+        .collect())
+}
+
+pub async fn scan_rows(
+    client: &HBaseClient,
+    namespace: &str,
+    table: &str,
+    row_key_prefix: Option<&str>,
+    limit: usize,
+) -> Result<HBaseScanResult, String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let limit = limit.clamp(1, 1000);
+    let prefix = row_key_prefix.map(str::as_bytes).filter(|value| !value.is_empty());
+    let mut scanner = Map::new();
+    scanner.insert("batch".to_string(), Value::from((limit.saturating_mul(10)).clamp(10, 1000) as u64));
+    scanner.insert("maxVersions".to_string(), Value::from(1));
+    if let Some(prefix) = prefix {
+        scanner.insert("startRow".to_string(), Value::String(BASE64.encode(prefix)));
+        if let Some(end) = prefix_range_end(prefix) {
+            scanner.insert("endRow".to_string(), Value::String(BASE64.encode(end)));
+        }
+    }
+
+    let create_path = format!("/{}/scanner", path_segment(&qualified));
+    let response = client
+        .request(reqwest::Method::PUT, &create_path)
+        .header(reqwest::header::CONTENT_TYPE, HBASE_JSON)
+        .json(&Value::Object(scanner))
+        .send()
+        .await
+        .map_err(|error| format_request_error("create scanner", error))?;
+    let response = ensure_success(response, "create scanner").await?;
+    let scanner_url = response
+        .headers()
+        .get(reqwest::header::LOCATION)
+        .and_then(|value| value.to_str().ok())
+        .map(str::to_string)
+        .ok_or_else(|| "HBase REST did not return a scanner location".to_string())?;
+
+    let scan_result = read_scanner(client, &scanner_url, limit).await;
+    let close_result = close_scanner(client, &scanner_url).await;
+    match (scan_result, close_result) {
+        (Ok(result), Ok(())) => Ok(result),
+        (Ok(_), Err(error)) => Err(error),
+        (Err(error), _) => Err(error),
+    }
+}
+
+pub async fn get_row(
+    client: &HBaseClient,
+    namespace: &str,
+    table: &str,
+    row_key: &str,
+    row_key_encoding: Option<&str>,
+) -> Result<Option<HBaseRow>, String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let row_key_bytes = decode_input(row_key, row_key_encoding, "row key")?;
+    if row_key_bytes.is_empty() {
+        return Err("HBase row key cannot be empty".to_string());
+    }
+    let path = encoded_row_path(&qualified, &row_key_bytes);
+    let response = client
+        .request(reqwest::Method::GET, &path)
+        .header(HBASE_KEY_ENCODING_HEADER, HBASE_KEY_ENCODING_BASE64)
+        .header(reqwest::header::ACCEPT, HBASE_JSON)
+        .send()
+        .await
+        .map_err(|error| format_request_error("read row", error))?;
+    if response.status() == StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+    let body: RestRows = parse_success_json(response, "read row").await?;
+    let mut rows = decode_rest_rows(body.rows)?;
+    Ok(rows.pop())
+}
+
+pub async fn put_row(
+    client: &HBaseClient,
+    namespace: &str,
+    table: &str,
+    input: &HBasePutRowInput,
+) -> Result<(), String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let row_key = decode_input(&input.row_key, input.row_key_encoding.as_deref(), "row key")?;
+    if row_key.is_empty() {
+        return Err("HBase row key cannot be empty".to_string());
+    }
+    if input.cells.is_empty() {
+        return Err("At least one HBase cell is required".to_string());
+    }
+    let mut cells = Vec::with_capacity(input.cells.len());
+    for cell in &input.cells {
+        validate_column_name(&cell.column)?;
+        let value = decode_input(&cell.value, cell.value_encoding.as_deref(), "cell value")?;
+        cells.push(serde_json::json!({
+            "column": BASE64.encode(cell.column.as_bytes()),
+            "$": BASE64.encode(value),
+        }));
+    }
+    let body = serde_json::json!({
+        "Row": [{
+            "key": BASE64.encode(&row_key),
+            "Cell": cells,
+        }]
+    });
+    let path = encoded_row_path(&qualified, &row_key);
+    let response = client
+        .request(reqwest::Method::PUT, &path)
+        .header(HBASE_KEY_ENCODING_HEADER, HBASE_KEY_ENCODING_BASE64)
+        .header(reqwest::header::CONTENT_TYPE, HBASE_JSON)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|error| format_request_error("write row", error))?;
+    ensure_success(response, "write row").await.map(|_| ())
+}
+
+pub async fn delete_row(
+    client: &HBaseClient,
+    namespace: &str,
+    table: &str,
+    row_key: &str,
+    row_key_encoding: Option<&str>,
+) -> Result<(), String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let row_key = decode_input(row_key, row_key_encoding, "row key")?;
+    if row_key.is_empty() {
+        return Err("HBase row key cannot be empty".to_string());
+    }
+    let path = encoded_row_path(&qualified, &row_key);
+    let response = client
+        .request(reqwest::Method::DELETE, &path)
+        .header(HBASE_KEY_ENCODING_HEADER, HBASE_KEY_ENCODING_BASE64)
+        .send()
+        .await
+        .map_err(|error| format_request_error("delete row", error))?;
+    ensure_success(response, "delete row").await.map(|_| ())
+}
+
+pub async fn create_table(
+    client: &HBaseClient,
+    namespace: &str,
+    table: &str,
+    column_families: &[String],
+) -> Result<(), String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    if column_families.is_empty() {
+        return Err("At least one HBase column family is required".to_string());
+    }
+    let mut families = Vec::with_capacity(column_families.len());
+    for family in column_families {
+        validate_family_name(family)?;
+        families.push(serde_json::json!({ "name": family.trim() }));
+    }
+    let path = format!("/{}/schema", path_segment(&qualified));
+    let response = client
+        .request(reqwest::Method::PUT, &path)
+        .header(reqwest::header::CONTENT_TYPE, HBASE_JSON)
+        .json(&serde_json::json!({ "ColumnSchema": families }))
+        .send()
+        .await
+        .map_err(|error| format_request_error("create table", error))?;
+    ensure_success(response, "create table").await.map(|_| ())
+}
+
+pub async fn delete_table(client: &HBaseClient, namespace: &str, table: &str) -> Result<(), String> {
+    let qualified = qualified_table_name(namespace, table)?;
+    let path = format!("/{}/schema", path_segment(&qualified));
+    let response = client
+        .request(reqwest::Method::DELETE, &path)
+        .send()
+        .await
+        .map_err(|error| format_request_error("delete table", error))?;
+    ensure_success(response, "delete table").await.map(|_| ())
+}
+
+async fn read_scanner(client: &HBaseClient, scanner_url: &str, limit: usize) -> Result<HBaseScanResult, String> {
+    let mut order = Vec::<String>::new();
+    let mut rows = HashMap::<String, RestRow>::new();
+    let mut exhausted = false;
+
+    while rows.len() <= limit {
+        let response = client
+            .scanner_request(reqwest::Method::GET, scanner_url)?
+            .header(reqwest::header::ACCEPT, HBASE_JSON)
+            .send()
+            .await
+            .map_err(|error| format_request_error("read scanner", error))?;
+        if response.status() == StatusCode::NO_CONTENT {
+            exhausted = true;
+            break;
+        }
+        let body: RestRows = parse_success_json(response, "read scanner").await?;
+        if body.rows.is_empty() {
+            exhausted = true;
+            break;
+        }
+        for row in body.rows {
+            let key = row.key.clone();
+            if let Some(existing) = rows.get_mut(&key) {
+                existing.cells.extend(row.cells);
+            } else {
+                order.push(key.clone());
+                rows.insert(key, row);
+            }
+        }
+        if rows.len() > limit {
+            break;
+        }
+    }
+
+    let truncated = !exhausted && rows.len() >= limit;
+    let mut ordered_rows = Vec::with_capacity(order.len().min(limit));
+    for key in order.into_iter().take(limit) {
+        if let Some(row) = rows.remove(&key) {
+            ordered_rows.push(row);
+        }
+    }
+    Ok(HBaseScanResult { rows: decode_rest_rows(ordered_rows)?, truncated })
+}
+
+async fn close_scanner(client: &HBaseClient, scanner_url: &str) -> Result<(), String> {
+    let response = client
+        .scanner_request(reqwest::Method::DELETE, scanner_url)?
+        .send()
+        .await
+        .map_err(|error| format_request_error("close scanner", error))?;
+    if response.status() == StatusCode::NOT_FOUND {
+        return Ok(());
+    }
+    ensure_success(response, "close scanner").await.map(|_| ())
+}
+
+fn decode_rest_rows(rows: Vec<RestRow>) -> Result<Vec<HBaseRow>, String> {
+    rows.into_iter()
+        .map(|row| {
+            let row_key_bytes =
+                BASE64.decode(&row.key).map_err(|error| format!("Invalid HBase row key Base64: {error}"))?;
+            let (row_key, row_key_encoding) = display_bytes(&row_key_bytes);
+            let mut cells = row
+                .cells
+                .into_iter()
+                .map(|cell| {
+                    let column_bytes =
+                        BASE64.decode(&cell.column).map_err(|error| format!("Invalid HBase column Base64: {error}"))?;
+                    let column = String::from_utf8(column_bytes)
+                        .map_err(|_| "HBase returned a non-UTF-8 column identifier".to_string())?;
+                    let value_bytes =
+                        BASE64.decode(&cell.value).map_err(|error| format!("Invalid HBase cell Base64: {error}"))?;
+                    let value_base64 = BASE64.encode(&value_bytes);
+                    let (value, value_encoding) = display_bytes(&value_bytes);
+                    Ok(HBaseCell { column, value, value_encoding, value_base64, timestamp: cell.timestamp })
+                })
+                .collect::<Result<Vec<_>, String>>()?;
+            cells.sort_by(|left, right| left.column.cmp(&right.column));
+            Ok(HBaseRow { row_key, row_key_encoding, row_key_base64: BASE64.encode(row_key_bytes), cells })
+        })
+        .collect()
+}
+
+fn parse_table_schema(body: Value) -> Result<HBaseTableSchema, String> {
+    let object = body.as_object().ok_or_else(|| "Invalid HBase table schema response".to_string())?;
+    let name = object.get("name").and_then(Value::as_str).unwrap_or_default().to_string();
+    let mut column_families = Vec::new();
+    for raw_family in object.get("ColumnSchema").and_then(Value::as_array).into_iter().flatten() {
+        let family = raw_family.as_object().ok_or_else(|| "Invalid HBase column family response".to_string())?;
+        let family_name = family.get("name").and_then(Value::as_str).unwrap_or_default().to_string();
+        if family_name.is_empty() {
+            continue;
+        }
+        column_families.push(HBaseColumnFamily { name: family_name, properties: string_properties(family, &["name"]) });
+    }
+    column_families.sort_by(|left, right| left.name.cmp(&right.name));
+    Ok(HBaseTableSchema { name, column_families, properties: string_properties(object, &["name", "ColumnSchema"]) })
+}
+
+fn string_properties(object: &Map<String, Value>, excluded: &[&str]) -> BTreeMap<String, String> {
+    object
+        .iter()
+        .filter(|(key, _)| !excluded.contains(&key.as_str()))
+        .filter_map(|(key, value)| match value {
+            Value::String(value) => Some((key.clone(), value.clone())),
+            Value::Bool(value) => Some((key.clone(), value.to_string())),
+            Value::Number(value) => Some((key.clone(), value.to_string())),
+            _ => None,
+        })
+        .collect()
+}
+
+fn json_string(value: &Value, key: &str) -> Option<String> {
+    value.get(key).and_then(Value::as_str).map(str::to_string)
+}
+
+async fn send_json(request: RequestBuilder, action: &str) -> Result<Value, String> {
+    let response = request
+        .header(reqwest::header::ACCEPT, HBASE_JSON)
+        .send()
+        .await
+        .map_err(|error| format_request_error(action, error))?;
+    parse_success_json(response, action).await
+}
+
+async fn parse_success_json<T: serde::de::DeserializeOwned>(response: Response, action: &str) -> Result<T, String> {
+    let response = ensure_success(response, action).await?;
+    response.json::<T>().await.map_err(|error| format!("HBase failed to parse {action} response: {error}"))
+}
+
+async fn ensure_success(response: Response, action: &str) -> Result<Response, String> {
+    let status = response.status();
+    if status.is_success() {
+        return Ok(response);
+    }
+    let body = response.text().await.unwrap_or_default();
+    let detail = body.trim();
+    if detail.is_empty() {
+        Err(format!("HBase {action} failed ({status})"))
+    } else {
+        Err(format!("HBase {action} failed ({status}): {detail}"))
+    }
+}
+
+fn format_request_error(action: &str, error: reqwest::Error) -> String {
+    format!("HBase {action} request failed: {error}")
+}
+
+fn qualified_table_name(namespace: &str, table: &str) -> Result<String, String> {
+    let namespace = namespace.trim();
+    let table = table.trim();
+    if table.is_empty() {
+        return Err("HBase table name cannot be empty".to_string());
+    }
+    if table.contains(':') {
+        return Ok(table.to_string());
+    }
+    if namespace.is_empty() || namespace == DEFAULT_NAMESPACE {
+        Ok(table.to_string())
+    } else {
+        Ok(format!("{namespace}:{table}"))
+    }
+}
+
+fn table_name_in_namespace(qualified: &str, namespace: &str) -> Option<String> {
+    let namespace = namespace.trim();
+    match qualified.split_once(':') {
+        Some((table_namespace, table)) if table_namespace == namespace => Some(table.to_string()),
+        Some(_) => None,
+        None if namespace.is_empty() || namespace == DEFAULT_NAMESPACE => Some(qualified.to_string()),
+        None => None,
+    }
+}
+
+fn validate_family_name(value: &str) -> Result<(), String> {
+    let value = value.trim();
+    if value.is_empty() {
+        return Err("HBase column family name cannot be empty".to_string());
+    }
+    if value.contains(':') {
+        return Err(format!("HBase column family name cannot contain ':': {value}"));
+    }
+    Ok(())
+}
+
+fn validate_column_name(value: &str) -> Result<(), String> {
+    let Some((family, qualifier)) = value.split_once(':') else {
+        return Err(format!("HBase column must use family:qualifier syntax: {value}"));
+    };
+    validate_family_name(family)?;
+    if qualifier.is_empty() {
+        return Err(format!("HBase column qualifier cannot be empty: {value}"));
+    }
+    Ok(())
+}
+
+fn decode_input(value: &str, encoding: Option<&str>, label: &str) -> Result<Vec<u8>, String> {
+    let encoding = encoding.unwrap_or("utf8").trim();
+    if encoding.eq_ignore_ascii_case("base64") {
+        BASE64.decode(value.trim()).map_err(|error| format!("Invalid Base64 {label}: {error}"))
+    } else if encoding.eq_ignore_ascii_case("utf8") || encoding.is_empty() {
+        Ok(value.as_bytes().to_vec())
+    } else {
+        Err(format!("Unsupported HBase {label} encoding: {encoding}"))
+    }
+}
+
+fn display_bytes(bytes: &[u8]) -> (String, String) {
+    match std::str::from_utf8(bytes) {
+        Ok(text) if text.chars().all(|ch| !ch.is_control() || matches!(ch, '\n' | '\r' | '\t')) => {
+            (text.to_string(), "utf8".to_string())
+        }
+        _ => (format!("base64:{}", BASE64.encode(bytes)), "base64".to_string()),
+    }
+}
+
+fn prefix_range_end(prefix: &[u8]) -> Option<Vec<u8>> {
+    let mut end = prefix.to_vec();
+    for index in (0..end.len()).rev() {
+        if end[index] != u8::MAX {
+            end[index] += 1;
+            end.truncate(index + 1);
+            return Some(end);
+        }
+    }
+    None
+}
+
+fn path_segment(value: &str) -> String {
+    utf8_percent_encode(value, PATH_SEGMENT_ENCODE_SET).to_string()
+}
+
+fn encoded_row_path(qualified_table: &str, row_key: &[u8]) -> String {
+    format!("/{}/{}", path_segment(qualified_table), BASE64_URL.encode(row_key))
+}
+
+fn scanner_resource_path(location: &str) -> Result<String, String> {
+    let location = location.trim();
+    if location.is_empty() {
+        return Err("HBase REST returned an empty scanner location".to_string());
+    }
+    if let Ok(url) = reqwest::Url::parse(location) {
+        let mut path = url.path().to_string();
+        if let Some(query) = url.query() {
+            path.push('?');
+            path.push_str(query);
+        }
+        return Ok(path);
+    }
+    Ok(if location.starts_with('/') { location.to_string() } else { format!("/{location}") })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[test]
+    fn namespace_table_names_are_filtered_and_unqualified() {
+        assert_eq!(table_name_in_namespace("orders", "default"), Some("orders".to_string()));
+        assert_eq!(table_name_in_namespace("sales:orders", "sales"), Some("orders".to_string()));
+        assert_eq!(table_name_in_namespace("sales:orders", "default"), None);
+        assert_eq!(qualified_table_name("sales", "orders").unwrap(), "sales:orders");
+        assert_eq!(qualified_table_name("default", "orders").unwrap(), "orders");
+    }
+
+    #[test]
+    fn prefix_range_end_handles_carry_and_unbounded_prefix() {
+        assert_eq!(prefix_range_end(b"customer#00"), Some(b"customer#01".to_vec()));
+        assert_eq!(prefix_range_end(&[0x01, 0xff]), Some(vec![0x02]));
+        assert_eq!(prefix_range_end(&[0xff, 0xff]), None);
+    }
+
+    #[test]
+    fn binary_values_keep_base64_representation() {
+        assert_eq!(display_bytes(b"hello"), ("hello".to_string(), "utf8".to_string()));
+        assert_eq!(display_bytes(&[0, 1, 2]), ("base64:AAEC".to_string(), "base64".to_string()));
+    }
+
+    #[test]
+    fn row_paths_use_url_safe_base64_for_arbitrary_keys() {
+        assert_eq!(encoded_row_path("demo", b"customer#001"), "/demo/Y3VzdG9tZXIjMDAx");
+        assert_eq!(encoded_row_path("demo", &[0, 1, 2, 0xfb, 0xff]), "/demo/AAEC-_8");
+    }
+
+    #[test]
+    fn table_schema_properties_are_preserved() {
+        let schema = parse_table_schema(serde_json::json!({
+            "name": "demo",
+            "ColumnSchema": [{"name": "cf", "VERSIONS": "3", "COMPRESSION": "SNAPPY"}],
+            "IS_META": "false"
+        }))
+        .unwrap();
+        assert_eq!(schema.name, "demo");
+        assert_eq!(schema.column_families[0].name, "cf");
+        assert_eq!(schema.column_families[0].properties.get("VERSIONS").map(String::as_str), Some("3"));
+        assert_eq!(schema.properties.get("IS_META").map(String::as_str), Some("false"));
+    }
+
+    #[test]
+    fn scanner_location_reuses_the_configured_gateway_origin() {
+        assert_eq!(
+            scanner_resource_path("http://hbase.internal:8080/dbx/scanner/123?token=abc").unwrap(),
+            "/dbx/scanner/123?token=abc"
+        );
+        assert_eq!(scanner_resource_path("/dbx/scanner/123").unwrap(), "/dbx/scanner/123");
+        assert_eq!(scanner_resource_path("dbx/scanner/123").unwrap(), "/dbx/scanner/123");
+    }
+
+    #[tokio::test]
+    #[ignore = "requires DBX_TEST_HBASE_URL and a writable HBase REST gateway"]
+    async fn live_hbase_rest_crud_and_scan() {
+        let url = std::env::var("DBX_TEST_HBASE_URL").expect("DBX_TEST_HBASE_URL is required");
+        let username = std::env::var("DBX_TEST_HBASE_USERNAME").ok();
+        let password = std::env::var("DBX_TEST_HBASE_PASSWORD").ok();
+        let client = HBaseClient::new(&url, username.as_deref(), password.as_deref(), false, Duration::from_secs(5))
+            .expect("create HBase client");
+        let suffix = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis();
+        let table = format!("dbx_hbase_live_{suffix}");
+        let namespace = "default";
+
+        let version = test_connection(&client, Duration::from_secs(5)).await.expect("test connection");
+        assert!(!version.version.is_empty());
+        let namespaces = list_namespaces(&client).await.expect("list namespaces");
+        assert!(namespaces.iter().any(|item| item.name == namespace));
+
+        create_table(&client, namespace, &table, &["profile".to_string(), "metrics".to_string()])
+            .await
+            .expect("create table");
+        let test_result: Result<(), String> = async {
+            let tables = list_tables(&client, namespace).await?;
+            if !tables.iter().any(|item| item.name == table) {
+                return Err("created table is missing from the table list".to_string());
+            }
+            let schema = get_table_schema(&client, namespace, &table).await?;
+            if schema.column_families.iter().map(|family| family.name.as_str()).collect::<Vec<_>>()
+                != vec!["metrics", "profile"]
+            {
+                return Err(format!("unexpected column families: {:?}", schema.column_families));
+            }
+
+            for (key, name, score) in
+                [("customer#001", "Alice", "10"), ("customer#002", "Bob", "20"), ("customer#003", "Carol", "30")]
+            {
+                put_row(
+                    &client,
+                    namespace,
+                    &table,
+                    &HBasePutRowInput {
+                        row_key: key.to_string(),
+                        row_key_encoding: Some("utf8".to_string()),
+                        cells: vec![
+                            HBaseCellInput {
+                                column: "profile:name".to_string(),
+                                value: name.to_string(),
+                                value_encoding: Some("utf8".to_string()),
+                            },
+                            HBaseCellInput {
+                                column: "metrics:score".to_string(),
+                                value: score.to_string(),
+                                value_encoding: Some("utf8".to_string()),
+                            },
+                        ],
+                    },
+                )
+                .await?;
+            }
+
+            let limited = scan_rows(&client, namespace, &table, Some("customer#00"), 2).await?;
+            if limited.rows.len() != 2 || !limited.truncated {
+                return Err(format!("unexpected limited scan result: {limited:?}"));
+            }
+            let all = scan_rows(&client, namespace, &table, Some("customer#00"), 10).await?;
+            if all.rows.iter().map(|row| row.row_key.as_str()).collect::<Vec<_>>()
+                != vec!["customer#001", "customer#002", "customer#003"]
+                || all.truncated
+            {
+                return Err(format!("unexpected full scan result: {all:?}"));
+            }
+
+            let row = get_row(&client, namespace, &table, "customer#002", Some("utf8"))
+                .await?
+                .ok_or_else(|| "customer#002 is missing".to_string())?;
+            if !row.cells.iter().any(|cell| cell.column == "profile:name" && cell.value == "Bob") {
+                return Err(format!("unexpected customer#002 row: {row:?}"));
+            }
+            put_row(
+                &client,
+                namespace,
+                &table,
+                &HBasePutRowInput {
+                    row_key: "customer#002".to_string(),
+                    row_key_encoding: Some("utf8".to_string()),
+                    cells: vec![HBaseCellInput {
+                        column: "metrics:score".to_string(),
+                        value: "25".to_string(),
+                        value_encoding: Some("utf8".to_string()),
+                    }],
+                },
+            )
+            .await?;
+            let updated = get_row(&client, namespace, &table, "customer#002", Some("utf8"))
+                .await?
+                .ok_or_else(|| "updated customer#002 is missing".to_string())?;
+            if !updated.cells.iter().any(|cell| cell.column == "metrics:score" && cell.value == "25") {
+                return Err(format!("updated cell is missing: {updated:?}"));
+            }
+
+            put_row(
+                &client,
+                namespace,
+                &table,
+                &HBasePutRowInput {
+                    row_key: "AAEC".to_string(),
+                    row_key_encoding: Some("base64".to_string()),
+                    cells: vec![HBaseCellInput {
+                        column: "profile:binary".to_string(),
+                        value: "/wA=".to_string(),
+                        value_encoding: Some("base64".to_string()),
+                    }],
+                },
+            )
+            .await?;
+            let binary = get_row(&client, namespace, &table, "AAEC", Some("base64"))
+                .await?
+                .ok_or_else(|| "binary row is missing".to_string())?;
+            if binary.row_key != "base64:AAEC"
+                || !binary.cells.iter().any(|cell| {
+                    cell.column == "profile:binary" && cell.value == "base64:/wA=" && cell.value_base64 == "/wA="
+                })
+            {
+                return Err(format!("unexpected binary row: {binary:?}"));
+            }
+
+            delete_row(&client, namespace, &table, "customer#003", Some("utf8")).await?;
+            if get_row(&client, namespace, &table, "customer#003", Some("utf8")).await?.is_some() {
+                return Err("customer#003 still exists after deletion".to_string());
+            }
+            Ok(())
+        }
+        .await;
+
+        let cleanup_result = delete_table(&client, namespace, &table).await;
+        if let Err(error) = test_result {
+            panic!("live HBase test failed: {error:?}; cleanup result: {cleanup_result:?}");
+        }
+        cleanup_result.expect("delete temporary table");
+        let tables = list_tables(&client, namespace).await.expect("list tables after cleanup");
+        assert!(!tables.iter().any(|item| item.name == table));
+    }
+}
diff --git a/crates/dbx-core/src/db/mod.rs b/crates/dbx-core/src/db/mod.rs
index ebf99ceaf2..d16b192481 100644
--- a/crates/dbx-core/src/db/mod.rs
+++ b/crates/dbx-core/src/db/mod.rs
@@ -16,6 +16,7 @@ pub mod duckdb_worker_runtime;
 pub mod elasticsearch_driver;
 pub mod elasticsearch_sql;
 pub mod file_validator;
+pub mod hbase_driver;
 pub mod http_tunnel;
 pub mod influxdb_driver;
 pub mod manticoresearch;
diff --git a/crates/dbx-core/src/hbase_ops.rs b/crates/dbx-core/src/hbase_ops.rs
new file mode 100644
index 0000000000..bcacd1b863
--- /dev/null
+++ b/crates/dbx-core/src/hbase_ops.rs
@@ -0,0 +1,82 @@
+use crate::connection::{AppState, PoolKind};
+use crate::db::hbase_driver::{self, HBasePutRowInput, HBaseRow, HBaseScanResult, HBaseTableSchema};
+
+async fn client(state: &AppState, connection_id: &str) -> Result<hbase_driver::HBaseClient, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    match connections.get(&pool_key) {
+        Some(PoolKind::HBase(client)) => Ok(client.clone()),
+        _ => Err("Not an HBase connection".to_string()),
+    }
+}
+
+pub async fn get_table_schema_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+) -> Result<HBaseTableSchema, String> {
+    hbase_driver::get_table_schema(&client(state, connection_id).await?, namespace, table).await
+}
+
+pub async fn scan_rows_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+    row_key_prefix: Option<&str>,
+    limit: usize,
+) -> Result<HBaseScanResult, String> {
+    hbase_driver::scan_rows(&client(state, connection_id).await?, namespace, table, row_key_prefix, limit).await
+}
+
+pub async fn get_row_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+    row_key: &str,
+    row_key_encoding: Option<&str>,
+) -> Result<Option<HBaseRow>, String> {
+    hbase_driver::get_row(&client(state, connection_id).await?, namespace, table, row_key, row_key_encoding).await
+}
+
+pub async fn put_row_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+    input: &HBasePutRowInput,
+) -> Result<(), String> {
+    hbase_driver::put_row(&client(state, connection_id).await?, namespace, table, input).await
+}
+
+pub async fn delete_row_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+    row_key: &str,
+    row_key_encoding: Option<&str>,
+) -> Result<(), String> {
+    hbase_driver::delete_row(&client(state, connection_id).await?, namespace, table, row_key, row_key_encoding).await
+}
+
+pub async fn create_table_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+    column_families: &[String],
+) -> Result<(), String> {
+    hbase_driver::create_table(&client(state, connection_id).await?, namespace, table, column_families).await
+}
+
+pub async fn delete_table_core(
+    state: &AppState,
+    connection_id: &str,
+    namespace: &str,
+    table: &str,
+) -> Result<(), String> {
+    hbase_driver::delete_table(&client(state, connection_id).await?, namespace, table).await
+}
diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs
index b0e89ef39f..2a748792ac 100644
--- a/crates/dbx-core/src/lib.rs
+++ b/crates/dbx-core/src/lib.rs
@@ -28,6 +28,7 @@ pub mod db_admin_sql;
 pub mod document_ops;
 pub mod driver_runtime;
 pub mod external;
+pub mod hbase_ops;
 pub mod history;
 pub mod jdbc;
 pub mod models;
diff --git a/crates/dbx-core/src/models/connection.rs b/crates/dbx-core/src/models/connection.rs
index d3bd7966a2..c09240400a 100644
--- a/crates/dbx-core/src/models/connection.rs
+++ b/crates/dbx-core/src/models/connection.rs
@@ -455,6 +455,7 @@ pub enum DatabaseType {
     Oracle,
     #[serde(rename = "elasticsearch")]
     Elasticsearch,
+    Hbase,
     #[serde(rename = "qdrant")]
     Qdrant,
     #[serde(rename = "milvus")]
@@ -1001,6 +1002,7 @@ impl ConnectionConfig {
             }
             DatabaseType::Oracle => format!("oracle://{host}:{port}{db_part}"),
             DatabaseType::Elasticsearch
+            | DatabaseType::Hbase
             | DatabaseType::Qdrant
             | DatabaseType::Milvus
             | DatabaseType::Weaviate
@@ -1149,6 +1151,7 @@ impl ConnectionConfig {
                 format!("oracle://{}:{}@{host}:{port}{db_part}", username, password)
             }
             DatabaseType::Elasticsearch
+            | DatabaseType::Hbase
             | DatabaseType::Qdrant
             | DatabaseType::Milvus
             | DatabaseType::Weaviate
@@ -2762,6 +2765,20 @@ mod tests {
         assert_eq!(config.connection_url(), "https://10.1.2.3:8443");
     }
 
+    #[test]
+    fn hbase_rest_url_uses_http_or_https_without_embedding_credentials() {
+        let mut config = mysql_config("hbase-user", "secret", None);
+        config.db_type = DatabaseType::Hbase;
+        config.port = 8080;
+
+        assert_eq!(config.connection_url(), "http://10.1.2.3:8080");
+        assert_eq!(config.redacted_connection_url(), "http://10.1.2.3:8080");
+
+        config.ssl = true;
+        assert_eq!(config.connection_url(), "https://10.1.2.3:8080");
+        assert_eq!(config.redacted_connection_url(), "https://10.1.2.3:8080");
+    }
+
     #[test]
     fn clickhouse_host_may_include_http_scheme() {
         let mut config = mysql_config("default", "", None);
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
index c4ce164fb1..1a6738cd16 100644
--- a/crates/dbx-core/src/query.rs
+++ b/crates/dbx-core/src/query.rs
@@ -1696,6 +1696,7 @@ pub async fn do_execute(
             .await
             .map(|result| truncate_result_with_max_rows(result, max_rows))
         }
+        PoolKind::HBase(_) => Err("SQL execution is not supported for HBase connections".to_string()),
     };
     result.map(normalize_query_result_for_js)
 }
@@ -2592,7 +2593,7 @@ pub async fn execute_statements_in_transaction_on_pool(
             | PoolKind::Turso(_)
             | PoolKind::SqlServer(_)
             | PoolKind::Agent(_) => TxPath::Explicit,
-            PoolKind::MessageQueue | PoolKind::Nacos => TxPath::None,
+            PoolKind::MessageQueue | PoolKind::Nacos | PoolKind::HBase(_) => TxPath::None,
             #[cfg(feature = "duckdb-bundled")]
             PoolKind::DuckDb(_)
             | PoolKind::DuckDbWorker(_)
diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs
index e5e8a27b8d..5ce12b4908 100644
--- a/crates/dbx-core/src/schema.rs
+++ b/crates/dbx-core/src/schema.rs
@@ -1124,6 +1124,7 @@ async fn list_databases_once(state: &AppState, connection_id: &str) -> Result<Ve
         PoolKind::Postgres(p) => db::postgres::list_databases(p).await,
         PoolKind::Sqlite(p) => db::sqlite::list_databases(p).await,
         PoolKind::Rqlite(client) => db::rqlite_driver::list_databases(client).await,
+        PoolKind::HBase(client) => db::hbase_driver::list_namespaces(client).await,
         #[cfg(feature = "duckdb-bundled")]
         PoolKind::DuckDb(con) => {
             let con = con.lock().map_err(|e| e.to_string())?;
@@ -2473,6 +2474,9 @@ async fn list_tables_once(
             .await
             .map(|names| collection_names_to_tables(names, "INDEX"))
             .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types, table_name_filter)),
+        PoolKind::HBase(client) => db::hbase_driver::list_tables(client, database)
+            .await
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types, table_name_filter)),
         PoolKind::VectorDb(client) => db::vector_driver::list_collections(client)
             .await
             .map(|infos| collection_names_to_tables(infos.into_iter().map(|i| i.name).collect(), "COLLECTION"))
@@ -5215,6 +5219,9 @@ pub async fn get_columns_core_for_session(
             PoolKind::Elasticsearch(client) => {
                 db::elasticsearch_driver::get_columns(client, table).await.map(deduplicate_column_infos)
             }
+            PoolKind::HBase(client) => {
+                db::hbase_driver::get_columns(client, database, table).await.map(deduplicate_column_infos)
+            }
             _ => Ok(vec![]),
         }
     })
diff --git a/crates/dbx-core/src/schema/providers/native.rs b/crates/dbx-core/src/schema/providers/native.rs
index 81b75226ba..2db3bc6b1a 100644
--- a/crates/dbx-core/src/schema/providers/native.rs
+++ b/crates/dbx-core/src/schema/providers/native.rs
@@ -15,6 +15,7 @@ pub(in crate::schema) async fn list_databases(
         PoolKind::Postgres(p) => db::postgres::list_databases(p).await,
         PoolKind::Sqlite(p) => db::sqlite::list_databases(p).await,
         PoolKind::Rqlite(client) => db::rqlite_driver::list_databases(client).await,
+        PoolKind::HBase(client) => db::hbase_driver::list_namespaces(client).await,
         PoolKind::Turso(client) => db::turso_driver::list_databases(client).await,
         _ => Ok(vec![]),
     }
@@ -60,6 +61,7 @@ pub(in crate::schema) async fn list_tables(
         PoolKind::Elasticsearch(client) => {
             db::elasticsearch_driver::list_indices(client).await.map(|names| collection_names_to_tables(names, "INDEX"))
         }
+        PoolKind::HBase(client) => db::hbase_driver::list_tables(client, database).await,
         PoolKind::VectorDb(client) => db::vector_driver::list_collections(client)
             .await
             .map(|infos| collection_names_to_tables(infos.into_iter().map(|i| i.name).collect(), "COLLECTION")),
@@ -149,6 +151,7 @@ pub(in crate::schema) async fn get_columns(
         PoolKind::Rqlite(client) => db::rqlite_driver::get_columns(client, schema, table).await,
         PoolKind::Turso(client) => db::turso_driver::get_columns(client, schema, table).await,
         PoolKind::Elasticsearch(client) => db::elasticsearch_driver::get_columns(client, table).await,
+        PoolKind::HBase(client) => db::hbase_driver::get_columns(client, database, table).await,
         PoolKind::VectorDb(_) => Ok(vec![]),
         _ => Ok(vec![]),
     }
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index 78ee09e9d2..f2da2791e1 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -497,6 +497,14 @@ async fn main() {
         .route("/zookeeper/get", post(routes::zookeeper::get))
         .route("/zookeeper/put", post(routes::zookeeper::put))
         .route("/zookeeper/delete", post(routes::zookeeper::delete))
+        // HBase REST
+        .route("/hbase/table-schema", post(routes::hbase::get_table_schema))
+        .route("/hbase/scan-rows", post(routes::hbase::scan_rows))
+        .route("/hbase/get-row", post(routes::hbase::get_row))
+        .route("/hbase/put-row", post(routes::hbase::put_row))
+        .route("/hbase/delete-row", post(routes::hbase::delete_row))
+        .route("/hbase/create-table", post(routes::hbase::create_table))
+        .route("/hbase/delete-table", post(routes::hbase::delete_table))
         // Nacos
         .route("/nacos/test-connection", post(routes::nacos::test_connection))
         .route("/nacos/namespaces/list", post(routes::nacos::list_namespaces))
diff --git a/crates/dbx-web/src/routes/hbase.rs b/crates/dbx-web/src/routes/hbase.rs
new file mode 100644
index 0000000000..1f11871c10
--- /dev/null
+++ b/crates/dbx-web/src/routes/hbase.rs
@@ -0,0 +1,181 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use dbx_core::db::hbase_driver::{HBasePutRowInput, HBaseRow, HBaseScanResult, HBaseTableSchema};
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError::from(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseTableRequest {
+    pub connection_id: String,
+    pub namespace: String,
+    pub table: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseScanRequest {
+    pub connection_id: String,
+    pub namespace: String,
+    pub table: String,
+    pub row_key_prefix: Option<String>,
+    pub limit: Option<usize>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseRowRequest {
+    pub connection_id: String,
+    pub namespace: String,
+    pub table: String,
+    pub row_key: String,
+    pub row_key_encoding: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HBasePutRowRequest {
+    pub connection_id: String,
+    pub namespace: String,
+    pub table: String,
+    pub input: HBasePutRowInput,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HBaseCreateTableRequest {
+    pub connection_id: String,
+    pub namespace: String,
+    pub table: String,
+    pub column_families: Vec<String>,
+}
+
+pub async fn get_table_schema(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseTableRequest>,
+) -> Result<Json<HBaseTableSchema>, AppError> {
+    let result = dbx_core::hbase_ops::get_table_schema_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn scan_rows(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseScanRequest>,
+) -> Result<Json<HBaseScanResult>, AppError> {
+    let result = dbx_core::hbase_ops::scan_rows_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+        request.row_key_prefix.as_deref(),
+        request.limit.unwrap_or(100),
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn get_row(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseRowRequest>,
+) -> Result<Json<Option<HBaseRow>>, AppError> {
+    let result = dbx_core::hbase_ops::get_row_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+        &request.row_key,
+        request.row_key_encoding.as_deref(),
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(result))
+}
+
+pub async fn put_row(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBasePutRowRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &request.connection_id, "Write HBase row").await?;
+    dbx_core::hbase_ops::put_row_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+        &request.input,
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_row(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseRowRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &request.connection_id, "Delete HBase row").await?;
+    dbx_core::hbase_ops::delete_row_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+        &request.row_key,
+        request.row_key_encoding.as_deref(),
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn create_table(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseCreateTableRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &request.connection_id, "Create HBase table").await?;
+    dbx_core::hbase_ops::create_table_core(
+        &state.app,
+        &request.connection_id,
+        &request.namespace,
+        &request.table,
+        &request.column_families,
+    )
+    .await
+    .map_err(AppError::from)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_table(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<HBaseTableRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &request.connection_id, "Delete HBase table").await?;
+    dbx_core::hbase_ops::delete_table_core(&state.app, &request.connection_id, &request.namespace, &request.table)
+        .await
+        .map_err(AppError::from)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/mod.rs b/crates/dbx-web/src/routes/mod.rs
index 19be22fff4..f5b4d0da74 100644
--- a/crates/dbx-web/src/routes/mod.rs
+++ b/crates/dbx-web/src/routes/mod.rs
@@ -7,6 +7,7 @@ pub mod data_compare;
 pub mod database_export;
 pub mod document_store;
 pub mod etcd;
+pub mod hbase;
 pub mod history;
 pub mod jdbc;
 pub mod layout;
diff --git a/packages/app-tests/databaseCapabilities.test.ts b/packages/app-tests/databaseCapabilities.test.ts
index ed19887d48..f91a8eb318 100644
--- a/packages/app-tests/databaseCapabilities.test.ts
+++ b/packages/app-tests/databaseCapabilities.test.ts
@@ -45,8 +45,9 @@ test("only explicitly supported query schemas can be cleared from query tabs", (
   assert.equal(supportsClearableQuerySchema("jdbc"), false);
 });
 
-test("Nacos connection menus do not expose SQL-style query actions", () => {
+test("non-SQL connection menus do not expose SQL-style query actions", () => {
   assert.equal(supportsConnectionQueryActions("nacos"), false);
+  assert.equal(supportsConnectionQueryActions("hbase"), false);
   assert.equal(supportsConnectionQueryActions("mysql"), true);
   assert.equal(supportsConnectionQueryActions("redis"), true);
 });
diff --git a/packages/app-tests/sidebarActiveTabTarget.test.ts b/packages/app-tests/sidebarActiveTabTarget.test.ts
index c67cef4b6b..eb83ec79be 100644
--- a/packages/app-tests/sidebarActiveTabTarget.test.ts
+++ b/packages/app-tests/sidebarActiveTabTarget.test.ts
@@ -154,12 +154,7 @@ test("findNodePathForTarget handles loaded, unloaded, and MySQL schema fallback
         schema: "app_dev",
         tableName: "enum_info",
       },
-      expectedPath: [
-        "mysql-conn-1",
-        "mysql-conn-1:app_dev",
-        "mysql-conn-1:app_dev:__tables",
-        "mysql-conn-1:app_dev:__tables:enum_info",
-      ],
+      expectedPath: ["mysql-conn-1", "mysql-conn-1:app_dev", "mysql-conn-1:app_dev:__tables", "mysql-conn-1:app_dev:__tables:enum_info"],
     },
   ] satisfies Array<{
     name: string;
@@ -225,6 +220,33 @@ test("mongo tabs target the matching visible collection node", () => {
   assert.equal(findSidebarNodeForActiveTab(tab, [flat(collection)])?.id, "events-node");
 });
 
+test("HBase tabs target the matching table in their namespace", () => {
+  const tab: QueryTab = {
+    id: "tab-hbase",
+    title: "events",
+    connectionId: "conn-hbase",
+    database: "analytics",
+    sql: "events",
+    isExecuting: false,
+    mode: "hbase",
+  };
+  const table: TreeNode = {
+    id: "hbase-events",
+    label: "events",
+    type: "table",
+    connectionId: "conn-hbase",
+    database: "analytics",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "hbase-table",
+    connectionId: "conn-hbase",
+    namespace: "analytics",
+    tableName: "events",
+  });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(table)])?.id, "hbase-events");
+});
+
 test("GridFS tabs target the shared GridFS sidebar entry", () => {
   const managerTab: QueryTab = {
     id: "tab-gridfs",
diff --git a/packages/app-tests/tabPresentation.test.ts b/packages/app-tests/tabPresentation.test.ts
index 7209048279..0ad59a1008 100644
--- a/packages/app-tests/tabPresentation.test.ts
+++ b/packages/app-tests/tabPresentation.test.ts
@@ -1,7 +1,20 @@
 import { strict as assert } from "node:assert";
 import { test } from "vitest";
 import { createPinia, setActivePinia } from "pinia";
-import { activeResultRun, databaseDisplayNameForTab, executionSummaryItems, middleEllipsis, nextExecutionSummaryView, resultGridCacheKey, resultRunItems, resultSourceRange, resultSqlForGrid, tabDisplayTitle, tabModeLabel, tabularResultItems } from "../../apps/desktop/src/lib/tabs/tabPresentation.ts";
+import {
+  activeResultRun,
+  databaseDisplayNameForTab,
+  executionSummaryItems,
+  middleEllipsis,
+  nextExecutionSummaryView,
+  resultGridCacheKey,
+  resultRunItems,
+  resultSourceRange,
+  resultSqlForGrid,
+  tabDisplayTitle,
+  tabModeLabel,
+  tabularResultItems,
+} from "../../apps/desktop/src/lib/tabs/tabPresentation.ts";
 import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
 import type { ConnectionConfig, QueryResult, QueryTab } from "../../apps/desktop/src/types/database.ts";
 
@@ -125,6 +138,26 @@ test("zookeeper tabs use key browser labels", () => {
   }
 });
 
+test("HBase tabs identify the table and namespace", () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  useConnectionStore().addEphemeralConnection({
+    ...conn("conn-1"),
+    name: "HBase Dev",
+    db_type: "hbase",
+    port: 8080,
+  });
+  const t = (key: string) => key;
+
+  try {
+    const tab = queryTab({ mode: "hbase", database: "analytics", title: "events", sql: "events" });
+    assert.equal(tabDisplayTitle(tab, t), "events@analytics");
+    assert.equal(tabModeLabel(tab, t), "HBase");
+  } finally {
+    restoreStorage();
+  }
+});
+
 test("GridFS tabs use dedicated titles and labels", () => {
   const restoreStorage = installMemoryStorage();
   setActivePinia(createPinia());
diff --git a/src-tauri/src/commands/hbase_cmd.rs b/src-tauri/src/commands/hbase_cmd.rs
new file mode 100644
index 0000000000..c8519df7c0
--- /dev/null
+++ b/src-tauri/src/commands/hbase_cmd.rs
@@ -0,0 +1,98 @@
+use std::sync::Arc;
+
+use dbx_core::db::hbase_driver::{HBasePutRowInput, HBaseRow, HBaseScanResult, HBaseTableSchema};
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+
+#[tauri::command]
+pub async fn hbase_get_table_schema(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+) -> Result<HBaseTableSchema, String> {
+    dbx_core::hbase_ops::get_table_schema_core(&state, &connection_id, &namespace, &table).await
+}
+
+#[tauri::command]
+pub async fn hbase_scan_rows(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+    row_key_prefix: Option<String>,
+    limit: usize,
+) -> Result<HBaseScanResult, String> {
+    dbx_core::hbase_ops::scan_rows_core(&state, &connection_id, &namespace, &table, row_key_prefix.as_deref(), limit)
+        .await
+}
+
+#[tauri::command]
+pub async fn hbase_get_row(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+    row_key: String,
+    row_key_encoding: Option<String>,
+) -> Result<Option<HBaseRow>, String> {
+    dbx_core::hbase_ops::get_row_core(&state, &connection_id, &namespace, &table, &row_key, row_key_encoding.as_deref())
+        .await
+}
+
+#[tauri::command]
+pub async fn hbase_put_row(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+    input: HBasePutRowInput,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Write HBase row").await?;
+    dbx_core::hbase_ops::put_row_core(&state, &connection_id, &namespace, &table, &input).await
+}
+
+#[tauri::command]
+pub async fn hbase_delete_row(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+    row_key: String,
+    row_key_encoding: Option<String>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete HBase row").await?;
+    dbx_core::hbase_ops::delete_row_core(
+        &state,
+        &connection_id,
+        &namespace,
+        &table,
+        &row_key,
+        row_key_encoding.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn hbase_create_table(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+    column_families: Vec<String>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create HBase table").await?;
+    dbx_core::hbase_ops::create_table_core(&state, &connection_id, &namespace, &table, &column_families).await
+}
+
+#[tauri::command]
+pub async fn hbase_delete_table(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    namespace: String,
+    table: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete HBase table").await?;
+    dbx_core::hbase_ops::delete_table_core(&state, &connection_id, &namespace, &table).await
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 567bf49b36..30fa03b198 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -15,6 +15,7 @@ pub mod etcd_cmd;
 pub mod external_db;
 pub mod external_sql;
 pub mod fs_open;
+pub mod hbase_cmd;
 pub mod history;
 pub mod keychain;
 pub mod list_sql_files;
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 5a43d476a0..bf561294fb 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1630,6 +1630,13 @@ pub fn run() {
             commands::mongo_cmd::mongo_update_document,
             commands::mongo_cmd::mongo_update_documents,
             commands::document_cmd::document_delete_document,
+            commands::hbase_cmd::hbase_get_table_schema,
+            commands::hbase_cmd::hbase_scan_rows,
+            commands::hbase_cmd::hbase_get_row,
+            commands::hbase_cmd::hbase_put_row,
+            commands::hbase_cmd::hbase_delete_row,
+            commands::hbase_cmd::hbase_create_table,
+            commands::hbase_cmd::hbase_delete_table,
             commands::mongo_cmd::mongo_delete_document,
             commands::mongo_cmd::mongo_delete_documents,
             commands::mongo_cmd::mongo_find_one_and_update,