Download the PHP package nette/routing without Composer

On this page you can find all versions of the php package nette/routing. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.


After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package routing

Nette Routing: two-ways URL conversion

Downloads this Month Tests Coverage Status


The router is responsible for everything about URLs so that you no longer have to think about them. We will show:

It requires PHP version 8.1 and supports PHP up to 8.3.

Documentation can be found on the website.

Support Me

Do you like Nette Routing? Are you looking forward to the new features?

Buy me a coffee

Thank you!


More human URLs (or cool or pretty URLs) are more usable, more memorable, and contribute positively to SEO. Nette Framework keeps this in mind and fully meets developers' desires.

Let's start a little technically. A router is an object that implements the Nette\Routing\Router interface, which can decompose a URL into an array of parameters (method match) and, conversely, build a URL from an array of parameters (method constructUrl). Therefore, it is also said that the router is bidirectional. Nette brings a very elegant way to define how the URLs of your application look like.

You can use it in the same way in completely different cases, for the REST API, for applications where controllers are not used at all, etc.

Thus, routing is a separate and sophisticated layer of the application, thanks to which the look of URL addresses can be easily designed or changed when the entire application is ready, because it can be done without modification of the code or templates. Which gives developers huge freedom.

Route Collection

The most pleasant way to define the URL addresses in the application is via the class Nette\Routing\RouteList. The big advantage is that the whole router is defined in one place and is not so scattered in the form of annotations in all controllers.

The definition consists of a list of so-called routes, ie masks of URL addresses and their associated controllers and actions using a simple API. We do not have to name the routes.

Order of routes is important because they are tried sequentially from the first one to the last one. Basic rule is to declare routes from the most specific to the most general.

Now we have to let the router to work:

And vice versa, we will use the router to create the link:

Mask and Parameters

The mask describes the relative path based on the site root. The simplest mask is a static URL:

Often masks contain so-called parameters. They are enclosed in angle brackets (e.g. <year>).

We can specify a default value for the parameters directly in the mask and thus it becomes optional:

The route will now accept the URL, which will again display with parameter year: 2020.

The mask can describe not only the relative path based on the site root, but also the absolute path when it begins with a slash, or even the entire absolute URL when it begins with two slashes:

Validation Expressions

A validation condition can be specified for each parameter using regular expression . For example, let's set id to be only numerical, using \d+ regexp:

The default regular expression for all parameters is [^/]+, ie everything except the slash. If a parameter is supposed to match a slash as well, we set the regular expression to .+.

Optional Sequences

Square brackets denote optional parts of mask. Any part of mask may be set as optional, including those containing parameters:

Of course, when a parameter is part of an optional sequence, it also becomes optional. If it does not have a default value, it will be null.

Optional sections can also be in the domain:

Sequences may be freely nested and combined:

URL generator tries to keep the URL as short as possible, so what can be omitted is omitted. Therefore, for example, a route index[.html] generates a path /index. You can reverse this behavior by writing an exclamation mark after the left square bracket:

Optional parameters (ie. parameters having default value) without square brackets do behave as if wrapped like this:

To change how the rightmost slash is generated, i.e. instead of /homepage/ get a /homepage, adjust the route this way:


In the absolute path mask, we can use the following wildcards to avoid, for example, the need to write a domain to the mask, which may differ in the development and production environment:

Second Parameter

The second parameter of the route is array of default values ​​of individual parameters:

Or we can use this form, notice the rewriting of the validation regular expression:

These more talkative formats are useful for adding other metadata.

Filters and Translations

It's a good practice to write source code in English, but what if you need your website to have translated URL to different language? Simple routes such as:

will generate English URLs, such as /product/123 or /cart. If we want to have controllers and actions in the URL translated to Deutsch (e.g. /produkt/123 or /einkaufswagen), we can use a translation dictionary. To add it, we already need a "more talkative" variant of the second parameter:

Multiple dictionary keys can by used for the same controller. They will create various aliases for it. The last key is considered to be the canonical variant (i.e. the one that will be in the generated URL).

The translation table can be applied to any parameter in this way. However, if the translation does not exist, the original value is taken. We can change this behavior by adding Router::FILTER_STRICT => true and the route will then reject the URL if the value is not in the dictionary.

In addition to the translation dictionary in the form of an array, it is possible to set own translation functions:

The function Route::FILTER_IN converts between the parameter in the URL and the string, which is then passed to the controller, the function FILTER_OUT ensures the conversion in the opposite direction.

Global Filters

Besides filters for specific parameters, you can also define global filters that receive an associative array of all parameters that they can modify in any way and then return. Global filters are defined under null key.

Global filters give you the ability to adjust the behavior of the route in absolutely any way. We can use them, for example, to modify parameters based on other parameters. For example, translation <controller> and <action> based on the current value of parameter <lang>.

If a parameter has a custom filter defined and a global filter exists at the same time, custom FILTER_IN is executed before the global and vice versa global FILTER_OUT is executed before the custom. Thus, inside the global filter are the values of the parameters controller resp. action written in PascalCase resp. camelCase style.

OneWay flag

One-way routes are used to preserve the functionality of old URLs that the application no longer generates but still accepts. We flag them with oneWay:

When accessing the old URL, the controller automatically redirects to the new URL so that search engines do not index these pages twice (see [#SEO and canonization]).


Route collections can be grouped by subdomains:

You can also use [#wildcards] in your domain name:

Path Prefix

Route collections can be grouped by path in URL:


The above usage can be combined:

Query Parameters

Masks can also contain query parameters (parameters after the question mark in the URL). They cannot define a validation expression, but they can change the name under which they are passed to the controller:

Foo Parameters

We're going deeper now. Foo parameters are basically unnamed parameters which allow to match a regular expression. The following route matches /index, /index.html, /index.htm and /index.php:

It's also possible to explicitly define a string which will be used for URL generation. The string must be placed directly after the question mark. The following route is similar to the previous one, but generates /index.html instead of /index because the string .html is set as a "generated value".


A much simpler router than the Route Collection is SimpleRouter. It can be used when there's no need for a specific URL format, when mod_rewrite (or alternatives) is not available or when we simply do not want to bother with user-friendly URLs yet.

Generates addresses in roughly this form:

The parameter of the SimpleRouter constructor is a default controller & action, ie. action to be executed if we open e.g. without additional parameters.

SEO and Canonization

The framework increases SEO (search engine optimization) by preventing duplication of content at different URLs. If multiple addresses link to a same destination, eg /index and /index.html, the framework determines the first one as primary (canonical) and redirects the others to it using HTTP code 301. Thanks to this, search engines will not index pages twice and do not break their page rank. .

This process is called canonization. The canonical URL is the one generated by the router, i.e. by the first matching route in the collection without the OneWay flag. Therefore, in the collection, we list primary routes first.

Canonization is performed by the controller, more in the chapter canonization .


In order to use the HTTPS protocol, it is necessary to activate it on hosting and to configure the server.

Redirection of the entire site to HTTPS must be performed at the server level, for example using the .htaccess file in the root directory of our application, with HTTP code 301. The settings may differ depending on the hosting and looks something like this:

The router generates a URL with the same protocol as the page was loaded, so there is no need to set anything else.

However, if we exceptionally need different routes to run under different protocols, we will put it in the route mask:

Routing Debugger

We will not hide from you that routing may seem a bit magical at first, and before you get into it, Routing Debugger will be a good helper. This is a panel displayed in the Tracy Bar , which provides a clear list of routes as well as parameters that the router obtained from the URL.

The green bar with symbol ✓ represents the route that matched the current URL, the blue bars with symbols ≈ indicate the routes that would also match the URL if green did not overtake them. We see the current controller & action further.

Custom Router

The following lines are intended for very advanced users. You can create your own router and naturally add it into your route collection. The router is an implementation of the Router interface with two methods:

Method match processes the current request in the parameter [$httpRequest ](http-request-response#HTTP request) (which offers more than just URL) into the an array containing the name of the controller and its parameters. If it cannot process the request, it returns null.

Method constructUrl, on the other hand, generates an absolute URL from the array of parameters. It can use the information from parameter $refUrl, which is the current URL.

To add custom router to the route collection, use add():

All versions of routing with dependencies

PHP Build Version
Package Version
Requires php Version 8.1 - 8.3
nette/http Version ^3.2 || ~4.0.0
nette/utils Version ^4.0
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package nette/routing contains the following files

Loading the files please wait ....