Menus in Joomla

1. The Basics

1.1 What is a Menu?

A menu is a container. It is a named group of menu items, identified by a menutype such as mainmenu, footer, or usermenu.

A menu on its own does not appear anywhere on the frontend. To show it to visitors, you publish a Menu module that points to the menutype.

A menu is a list. A menu item is a page.

1.2 What is a Menu Item?

A menu item is a single navigation entry. It is much more than a link. A menu item defines:

• A URL (alias-based, SEF, or external).
• The page type, such as Single Article, Category Blog, Login Form, or External URL.
• The layout and its parameters.
• The template style to use.
• The access level and the language.
• The page metadata: title, description, robots.
• Which modules are shown on that page.

In Joomla, the menu item is the page.

1.3 Where Do I Find Menus?

In the Joomla 6 backend, you manage menus from several places:

System  → Menus → Menus              (containers)
System  → Menus → All Menu Items     (every item, across menus)
System  → Menus → Main Menu          (items inside Main Menu)
Modules → Menu                         (publish a menu on the frontend)

Administrator-side menus live in the same database table, but with a different client_id. We will come back to that later.

1.4 Menu vs Menu Item vs Menu Module

These three terms are often confused. They are not the same:

You can also create hidden menus: menus with items, but no Menu module rendering them. This is very useful for clean routing without polluting the navigation.

1.5 The Joomla Menu Hierarchy

It helps to picture how menus fit together:

Menu (container, a menutype)
 └── Menu Item (link + page definition, has an Itemid)
      └── Page / View
           ├── Component  (the main content)
           ├── Modules    (sidebar, header, footer)
           └── Parameters (layout, metadata, template, ACL)

A menu is only a container. The menu item is where Joomla actually configures a page.

1.6 Menu Items Define Pages

This is the part newcomers miss most often:

• An article does not automatically have a public page.
• A component view does not automatically have a public page.
• A menu item is what gives a piece of content a real page in the Joomla sense.

A category accessed without a menu item still renders, but Joomla has to guess an Itemid. That guess leads to fragile module assignments, wrong breadcrumbs, and unstable canonical URLs.

With a menu item, Joomla can confidently attach:

• A routing entry and a canonical URL.
• Module placements.
• Metadata and a page heading.
• A breadcrumb trail.
• A template style override.
• Layout parameters and a page class.

In Joomla, content is content. A page requires a menu item.

3. Menu Item Types in Detail

3.1 Articles (com_content)

3.2 System Links

System Links are the underrated heroes of Joomla menus. They allow you to build clean, flexible navigation without creating new content.

The Alias type is especially useful: one canonical page, multiple navigation paths, no duplicate content.

3.3 Wrapper

The Wrapper menu item embeds another URL inside an iframe on a Joomla page. It is handy for legacy tools, but be careful with X-Frame-Options and modern Content Security Policy rules.

3.4 Users Manager

The Users Manager provides frontend-facing pages for the user lifecycle:

• Login Form
• Registration Form
• User Profile
• Edit Profile
• Username Reminder
• Password Reset

These are the public-facing equivalents of backend user actions.

3.5 Tags, Contacts, Smart Search, Newsfeeds

Each core component ships its own menu item types. The pattern is always the same: a list view, a single item view, and sometimes a form view. Custom components do the same through XML metadata files in components/com_xxx/tmpl/.

5. Menu Items Control Modules

5.1 Module Assignment Options

For every module in Joomla, you choose where it should appear:

• On all pages.
• On no pages.
• Only on the pages selected.
• On all pages except those selected.

The "selected pages" are menu items. The relationship between modules and menu items lives in the #__modules_menu table.

5.2 Why This is Powerful

You can shape the entire layout per page without touching code:

Homepage slider           → only on the Home menu item
Sidebar with shop promo   → only on shop category items
Newsletter subscription   → everywhere except checkout
Login module              → only on the Login menu item

5.3 A Quick Rule of Thumb

If a module should appear in only one place, give that place its own menu item - even if the menu item is hidden.

7. Multilingual Menus

7.1 The Pattern

For a multilingual website, you typically create:

• One menu per language, for example mainmenu-en and mainmenu-nl.
• Associations between equivalent items across languages.
• One Home menu item per language, all marked as default.

7.2 Associations

Open a menu item and go to the Associations tab:

System → Menus → All Menu Items → [item] → Associations

Linking equivalent items enables:

• The Language Switcher module.
• "Same page, different language" routing.
• Correct hreflang tags.
• Translated breadcrumbs.

The association is stored in the #__associations table with context = com_menus.item.

7.3 Common Multilingual Mistakes

• Forgetting to set a Home menu item for every language.
• Mixing "All" language items with language-specific ones.
• Missing associations, so the language switcher drops users on the homepage.
• Different alias structures in different languages.

9. Routing and SEF

9.1 The Routing Pipeline

When a visitor opens a Joomla page, the system goes through several steps:

1. The browser sends a request, for example /news/joomla-6-released.
2. Joomla's router parses the URL.
3. The router finds the matching menu item, for example a Category Blog for news.
4. The Itemid is set, and then the component is resolved.
5. Joomla builds the parameters, assigns the modules, and renders the template.

The menu item is the anchor for the entire resolution.

9.2 SEF and Menu Items

With SEF URLs enabled, the menu item's alias becomes a URL path segment. Nested menu items produce nested paths:

Main Menu → News           (alias: news)
            └── Category Blog  (alias: products)
                 └── Article   (alias: laptops)

URL: /news/products/laptops

A clean alias strategy keeps URLs short, predictable, and SEO-friendly.

9.3 Canonical Pages

If two menu items point to the same content, Joomla emits a canonical <link rel="canonical"> to the menu item it considers primary. When you refactor navigation, verify this carefully - canonicals can flip unexpectedly.

9.4 SEO Benefits at a Glance

A well-architected menu structure gives you, for free:

• Clean URLs built from menu item aliases.
• Hierarchical paths that mirror the site's information architecture.
• Per-page metadata: browser title, description, and robots.
• Breadcrumb trails generated from the menu tree.
• Canonical tags that consolidate duplicate routes.
• Hreflang signals through multilingual associations.
• Topic clustering: children under a parent live under one URL path.

Bad menu architecture produces the opposite: duplicate content, ugly fallback URLs, conflicting canonicals, broken breadcrumbs, and hreflang mismatches.

A clean menu is the cheapest SEO win in Joomla.

11. Under the Hood (Developer View)

11.1 The #__menu Table

Every menu item, frontend or backend, lives in the same table. The most important columns are:

id                -- primary key, used as the Itemid
menutype          -- which menu it belongs to
title             -- visible label
alias             -- SEF segment
path              -- full alias path (parent/child/grandchild)
link              -- the underlying index.php?option=... query
type              -- component | url | alias | separator | heading
published         -- 0 = unpublished, 1 = published, -2 = trashed
parent_id         -- nesting parent
level             -- depth in tree
component_id      -- linked component
access            -- ACL access level
template_style_id -- template style override
params            -- JSON blob with layout and meta options
lft, rgt          -- nested set values
home              -- 1 = default page (per language)
language          -- '*' or a specific language code
client_id         -- 0 = frontend, 1 = administrator
publish_up        -- scheduled publish
publish_down      -- scheduled unpublish

The params column carries all the per-item layout configuration as JSON: show title, page class suffix, robots, blog layout, and more.

11.2 The #__menu_types Table

The #__menu_types table stores the menu containers, one row per menu (mainmenu, footer, usermenu, and so on).

Notice that the join is by string, not by ID. This is a deliberate Joomla quirk.

11.3 The #__modules_menu Table

This small but powerful table holds the relationship between modules and the menu items they appear on:

moduleid   -- which module
menuid     -- which menu item (Itemid)
             positive = "show on this item"
             negative = "show on all except these items"
             0        = "all pages"

This tiny table powers Joomla's entire per-page module strategy.

11.4 The Nested Set Model (lft and rgt)

Like categories, menu items use the Nested Set Model. Every item has lft and rgt values. A parent's range always wraps its children:

Main Menu Root         lft=1   rgt=10
├── Home               lft=2   rgt=3
└── News               lft=4   rgt=9
     ├── National       lft=5   rgt=6
     └── International  lft=7   rgt=8

To list all descendants of "News", you only need one query:

SELECT id, title
  FROM #__menu
 WHERE lft > 4 AND rgt < 9
 ORDER BY lft;

No recursion is needed. That is the trick.

11.5 The Rebuild Button

The All Menu Items screen has a Rebuild button in the toolbar:

System → Menus → All Menu Items → Rebuild

Rebuild recalculates the lft, rgt, level, and path columns from parent_id. Run it after:

• Importing items through SQL.
• A failed save.
• A migration from another site.
• Manual database edits that touched parent relations.

11.6 Useful SQL Snippets

List every published frontend menu item, in tree order:

SELECT id, menutype, title, alias, level, link
  FROM jos_menu
 WHERE client_id = 0
   AND published = 1
 ORDER BY lft;

Show which modules appear on which menu items:

SELECT m.id AS itemid, m.title AS page,
       mod.id AS moduleid, mod.title AS module
  FROM jos_menu m
  JOIN jos_modules_menu mm ON mm.menuid = m.id
  JOIN jos_modules mod     ON mod.id    = mm.moduleid
 WHERE m.client_id = 0
 ORDER BY m.lft;

Find orphaned module assignments that point to a deleted menu item:

SELECT mm.*
  FROM jos_modules_menu mm
  LEFT JOIN jos_menu m ON m.id = mm.menuid
 WHERE mm.menuid > 0 AND m.id IS NULL;

11.7 The PHP API

From PHP, you can work with menus through a clean API:

use Joomla\CMS\Factory;

$app  = Factory::getApplication();
$menu = $app->getMenu();        // SiteMenu or AdminMenu

$active = $menu->getActive();   // current menu item
$home   = $menu->getDefault();  // default page for current language
$item   = $menu->getItem(101);  // by id
$tree   = $menu->getTree();     // breadcrumb chain
$items  = $menu->getItems('menutype', 'mainmenu');

11.8 Events to Hook Into

Plugins can react to menu-related events:

13. Best Practices

If you only remember a few things from this article, remember these:

• Plan your menu structure before you create content. Menu items dictate URLs, modules, SEO, and ACL.
• Treat every "kind of page" as a candidate for its own menu item, even a hidden one.
• Keep aliases short, lowercase, hyphenated, and stable.
• Use Headings and Separators to group long dropdowns.
• Document hidden menus so future maintainers know they exist.
• Run Rebuild after migrations or any direct database changes.

15. Summary

In Joomla, a menu item is not just a link. It is a complete page definition that touches almost every layer of the system:

• Routing: the URL and the canonical link.
• Rendering: the layout, the template style, and the modules shown.
• Configuration: page title, metadata, page class, and robots.
• Access: who can see it and who can use it.
• Language: its multilingual partner.
• Context: the Itemid that ties everything together.

A well-planned menu structure saves time, prevents bugs, and makes a Joomla website easier to maintain for years. A bad menu structure creates problems that grow with the site: broken URLs, wrong modules, confusing canonicals, and SEO regressions.

If you are planning a new Joomla site, migrating from an older version, or you suspect that your current navigation causes problems, it pays to look at menus early. Master menu items and you master Joomla.