diff --git a/‎docs/api/component-properties.md‎
Lines changed: 24 additions & 0 deletions b/‎docs/api/component-properties.md‎
Lines changed: 24 additions & 0 deletions
diff --git a/‎docs/guides/navigation.md‎
Lines changed: 18 additions & 3 deletions b/‎docs/guides/navigation.md‎
Lines changed: 18 additions & 3 deletions
diff --git a/‎examples/hello-world/app/main_page.py‎
Lines changed: 30 additions & 1 deletion b/‎examples/hello-world/app/main_page.py‎
Lines changed: 30 additions & 1 deletion
diff --git a/‎src/pythonnative/native_views/android.py‎
Lines changed: 143 additions & 0 deletions b/‎src/pythonnative/native_views/android.py‎
Lines changed: 143 additions & 0 deletions
@@ -176,6 +176,30 @@ pn.Modal(*children, visible=show_modal, on_dismiss=handler, title="Confirm",
 
 Overlay dialog shown when `visible=True`.
 
+## TabBar
+
+```python
+pn.Element("TabBar", {
+    "items": [
+        {"name": "Home", "title": "Home"},
+        {"name": "Settings", "title": "Settings"},
+    ],
+    "active_tab": "Home",
+    "on_tab_select": handler,
+})
+```
+
+Native tab bar — typically created automatically by `Tab.Navigator`.
+
+| Platform | Native view              |
+|----------|--------------------------|
+| Android  | `BottomNavigationView`   |
+| iOS      | `UITabBar`               |
+
+- `items` — list of `{"name": str, "title": str}` dicts defining each tab
+- `active_tab` — the `name` of the currently active tab
+- `on_tab_select` — callback `(str) -> None` receiving the selected tab name
+
 ## FlatList
 
 ```python
 
@@ -3,7 +3,7 @@
 PythonNative offers two approaches to navigation:
 
 1. **Declarative navigators** (recommended) — component-based, inspired by React Navigation
-2. **Legacy push/pop** — imperative navigation via `use_navigation()`
+2. **Page-level push/pop** — imperative navigation via `use_navigation()` (for native page transitions)
 
 ## Declarative Navigation
 
@@ -54,7 +54,9 @@ def DetailScreen():
 
 ### Tab Navigator
 
-A tab navigator renders a tab bar and switches between screens.
+A tab navigator renders a **native tab bar** and switches between screens.
+On Android the tab bar is a `BottomNavigationView` from Material Components;
+on iOS it is a `UITabBar`.
 
 ```python
 from pythonnative.navigation import create_tab_navigator
@@ -71,6 +73,13 @@ def App():
     )
 ```
 
+The tab bar emits a `TabBar` element that maps to platform-native views:
+
+| Platform | Native view                  |
+|----------|------------------------------|
+| Android  | `BottomNavigationView`       |
+| iOS      | `UITabBar`                   |
+
 ### Drawer Navigator
 
 A drawer navigator provides a side menu for switching screens.
@@ -100,7 +109,10 @@ def HomeScreen():
 
 ### Nesting Navigators
 
-Navigators can be nested — for example, tabs containing stacks:
+Navigators can be nested — for example, tabs containing stacks.
+When a child navigator receives a `navigate()` call for an unknown route,
+it automatically **forwards** the request to its parent navigator.
+Similarly, `go_back()` at the root of a child stack forwards to the parent.
 
 ```python
 Stack = create_stack_navigator()
@@ -123,6 +135,9 @@ def App():
     )
 ```
 
+Inside `FeedScreen`, calling `nav.navigate("Settings")` will forward to the
+parent tab navigator and switch to the Settings tab.
+
 ## NavigationHandle API
 
 Inside any screen rendered by a navigator, `pn.use_navigation()` returns a handle with:
 
@@ -1,9 +1,11 @@
 import emoji
 
 import pythonnative as pn
+from pythonnative.navigation import NavigationContainer, create_tab_navigator
 
 MEDALS = [":1st_place_medal:", ":2nd_place_medal:", ":3rd_place_medal:"]
 
+Tab = create_tab_navigator()
 
 styles = pn.StyleSheet.create(
     title={"font_size": 24, "bold": True},
@@ -39,7 +41,8 @@ def counter_badge(initial: int = 0) -> pn.Element:
 
 
 @pn.component
-def MainPage() -> pn.Element:
+def HomeTab() -> pn.Element:
+    """Home tab — counter demo and push-navigation to other pages."""
     nav = pn.use_navigation()
     return pn.ScrollView(
         pn.Column(
@@ -55,3 +58,29 @@ def MainPage() -> pn.Element:
             style=styles["section"],
         )
     )
+
+
+@pn.component
+def SettingsTab() -> pn.Element:
+    """Settings tab — simple placeholder content."""
+    return pn.ScrollView(
+        pn.Column(
+            pn.Text("Settings", style=styles["title"]),
+            pn.Text("App version: 0.7.0", style=styles["subtitle"]),
+            pn.Text(
+                "This tab uses a native UITabBar on iOS " "and BottomNavigationView on Android.",
+                style=styles["subtitle"],
+            ),
+            style=styles["section"],
+        )
+    )
+
+
+@pn.component
+def MainPage() -> pn.Element:
+    return NavigationContainer(
+        Tab.Navigator(
+            Tab.Screen("Home", component=HomeTab, options={"title": "Home"}),
+            Tab.Screen("Settings", component=SettingsTab, options={"title": "Settings"}),
+        )
+    )
@@ -618,6 +618,148 @@ def onStopTrackingTouch(self, seekBar: Any) -> None:
             sb.setOnSeekBarChangeListener(SeekProxy(cb, min_val, rng))
 
 
+_android_tabbar_state: dict = {"callback": None, "items": []}
+
+
+class TabBarHandler(ViewHandler):
+    """Native tab bar using ``BottomNavigationView`` from Material Components.
+
+    Falls back to a horizontal ``LinearLayout`` with ``Button`` children
+    when Material Components is unavailable.
+    """
+
+    _is_material: bool = True
+
+    def create(self, props: Dict[str, Any]) -> Any:
+        try:
+            bnv = jclass("com.google.android.material.bottomnavigation.BottomNavigationView")(_ctx())
+            bnv.setBackgroundColor(parse_color_int("#FFFFFF"))
+            ViewGroupLP = jclass("android.view.ViewGroup$LayoutParams")
+            LayoutParams = jclass("android.widget.LinearLayout$LayoutParams")
+            lp = LayoutParams(ViewGroupLP.MATCH_PARENT, ViewGroupLP.WRAP_CONTENT)
+            bnv.setLayoutParams(lp)
+            self._is_material = True
+            self._apply_full(bnv, props)
+            return bnv
+        except Exception:
+            self._is_material = False
+            return self._create_fallback(props)
+
+    def _create_fallback(self, props: Dict[str, Any]) -> Any:
+        """Horizontal LinearLayout with Button children as a tab-bar fallback."""
+        LinearLayout = jclass("android.widget.LinearLayout")
+        ll = LinearLayout(_ctx())
+        ll.setOrientation(LinearLayout.HORIZONTAL)
+        ll.setBackgroundColor(parse_color_int("#F8F8F8"))
+        self._apply_fallback(ll, props)
+        return ll
+
+    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
+        if self._is_material:
+            self._apply_partial(native_view, changed)
+        else:
+            self._apply_fallback(native_view, changed)
+
+    def _apply_full(self, bnv: Any, props: Dict[str, Any]) -> None:
+        """Initial creation — all props are present."""
+        items = props.get("items", [])
+        self._set_menu(bnv, items)
+        self._set_active(bnv, props.get("active_tab"), items)
+        cb = props.get("on_tab_select")
+        if cb is not None:
+            self._set_listener(bnv, cb, items)
+
+    def _apply_partial(self, bnv: Any, changed: Dict[str, Any]) -> None:
+        """Reconciler update — only changed props are present."""
+        prev_items = _android_tabbar_state["items"]
+
+        if "items" in changed:
+            items = changed["items"]
+            self._set_menu(bnv, items)
+        else:
+            items = prev_items
+
+        if "active_tab" in changed:
+            self._set_active(bnv, changed["active_tab"], items)
+
+        if "on_tab_select" in changed:
+            cb = changed["on_tab_select"]
+            if cb is not None:
+                self._set_listener(bnv, cb, items)
+
+    def _set_menu(self, bnv: Any, items: list) -> None:
+        _android_tabbar_state["items"] = items
+        try:
+            menu = bnv.getMenu()
+            menu.clear()
+            for i, item in enumerate(items):
+                title = item.get("title", item.get("name", ""))
+                menu.add(0, i, i, str(title))
+        except Exception:
+            pass
+
+    def _set_active(self, bnv: Any, active: Any, items: list) -> None:
+        if active and items:
+            for i, item in enumerate(items):
+                if item.get("name") == active:
+                    try:
+                        bnv.setSelectedItemId(i)
+                    except Exception:
+                        pass
+                    break
+
+    def _set_listener(self, bnv: Any, cb: Callable, items: list) -> None:
+        _android_tabbar_state["callback"] = cb
+        _android_tabbar_state["items"] = items
+        try:
+            listener_cls = jclass("com.google.android.material.navigation.NavigationBarView$OnItemSelectedListener")
+
+            class _TabSelectProxy(dynamic_proxy(listener_cls)):
+                def __init__(self, callback: Callable, tab_items: list) -> None:
+                    super().__init__()
+                    self.callback = callback
+                    self.tab_items = tab_items
+
+                def onNavigationItemSelected(self, menu_item: Any) -> bool:
+                    idx = menu_item.getItemId()
+                    if 0 <= idx < len(self.tab_items):
+                        self.callback(self.tab_items[idx].get("name", ""))
+                    return True
+
+            bnv.setOnItemSelectedListener(_TabSelectProxy(cb, items))
+        except Exception:
+            pass
+
+    def _apply_fallback(self, ll: Any, props: Dict[str, Any]) -> None:
+        items = props.get("items", [])
+        active = props.get("active_tab")
+        cb = props.get("on_tab_select")
+        if "items" in props:
+            ll.removeAllViews()
+            for item in items:
+                name = item.get("name", "")
+                title = item.get("title", name)
+                btn = jclass("android.widget.Button")(_ctx())
+                btn.setText(str(title))
+                btn.setEnabled(name != active)
+                if cb is not None:
+                    tab_name = name
+
+                    def _make_click(n: str) -> Callable[[], None]:
+                        return lambda: cb(n)
+
+                    class _ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
+                        def __init__(self, callback: Callable[[], None]) -> None:
+                            super().__init__()
+                            self.callback = callback
+
+                        def onClick(self, view: Any) -> None:
+                            self.callback()
+
+                    btn.setOnClickListener(_ClickProxy(_make_click(tab_name)))
+                ll.addView(btn)
+
+
 class PressableHandler(ViewHandler):
     def create(self, props: Dict[str, Any]) -> Any:
         fl = jclass("android.widget.FrameLayout")(_ctx())
@@ -686,4 +828,5 @@ def register_handlers(registry: Any) -> None:
     registry.register("SafeAreaView", SafeAreaViewHandler())
     registry.register("Modal", ModalHandler())
     registry.register("Slider", SliderHandler())
+    registry.register("TabBar", TabBarHandler())
     registry.register("Pressable", PressableHandler())