Design

Edit this page

The design of the backend is ready for any kind of application. It's been created with Bootstrap 5, and some custom CSS and JavaScript code; all managed by Webpack via Symfony's Webpack Encore.

Like any other Symfony bundle, assets are copied to (or symlinked from) the public/bundles/ directory of your application when installing or updating the bundle. If this doesn't work for any reason, your backend won't display properly. In those cases, run this command to install those assets manually:

1
2
# remove the --symlink option if your system doesn't support symbolic links
$ php bin/console assets:install --symlink

Depending on your needs, there are several ways of customizing the design. Some of them require pure CSS/JavaScript code and others require overriding and/or creating new Twig templates.

Changing the Backend Icons

By default, EasyAdmin uses FontAwesome icons both for the built-in interface icons and any custom icons that you add to menu items, fields, form tabs, etc. The full FontAwesome icon set (~2,000 icons) is already included in EasyAdmin, so you don't need to download any of these icons.

If you prefer to use other icons, call the useCustomIconSet() in your dashboard:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
namespace App\Controller\Admin;

use EasyCorp\Bundle\EasyAdminBundle\Attribute\AdminDashboard;
use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
use EasyCorp\Bundle\EasyAdminBundle\Config\Option\IconSet;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractDashboardController;

#[AdminDashboard(routePath: '/admin', routeName: 'admin')]
class DashboardController extends AbstractDashboardController
{
    public function configureAssets(): Assets
    {
        return Assets::new()
            ->useCustomIconSet()
        ;
    }

    // ...
}

Then, whenever you define a custom icon for any EasyAdmin feature, use the full icon prefix and name (lucide:map-pin, ic:baseline-calendar-month, etc.) that you would typically use in Symfony UX Icons.

If all your icons use a common prefix (e.g. tabler: when using the Tabler icons), pass it to the useCustomIconSet() method:

1
return Assets::new()->useCustomIconSet('tabler');

Now, the tabler: prefix will be added automatically to all your custom icon names. This way, you can use names like user and file instead of tabler:user and tabler:file.

Modifying Backend Templates

Backend pages are created with multiple Twig templates and fragments. You can modify them in two ways:

  • Override EasyAdmin templates using Symfony's mechanism to override templates (this is the same for all bundles, not only EasyAdmin);
  • Replace EasyAdmin templates using EasyAdmin features.

Overriding Templates

Tip

Instead of using Symfony mechanism to override templates, you may consider using a similar but more powerful feature provided by EasyAdmin to replace templates, as explained in the next section.

Following Symfony's mechanism to override templates from bundles, you must create the templates/bundles/EasyAdminBundle/ directory in your application and then create new templates with the same path as the original templates. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
your-project/
├─ ...
└─ templates/
   └─ bundles/
      └─ EasyAdminBundle/
         ├─ layout.html.twig
         ├─ menu.html.twig
         ├─ crud/
         │  ├─ index.html.twig
         │  ├─ detail.html.twig
         │  └─ field/
         │     ├─ country.html.twig
         │     └─ text.html.twig
         ├─ label/
         │  └─ null.html.twig
         └─ page/
            ├─ content.html.twig
            └─ login.html.twig

Instead of creating the new templates from scratch, you can extend from the original templates and change only the parts you want to override. However, you must use a special syntax inside extends to avoid an infinite loop:

1
2
3
4
5
6
7
8
9
10
11
{# templates/bundles/EasyAdminBundle/layout.html.twig #}

{# DON'T DO THIS: it will cause an infinite loop #}
{% extends '@EasyAdmin/layout.html.twig' %}

{# DO THIS: the '!' symbol tells Symfony to extend from the original template #}
{% extends '@!EasyAdmin/layout.html.twig' %}

{% block sidebar %}
    {# ... #}
{% endblock %}

Replacing Templates

This option allows you to render certain parts of the backend with your own Twig templates. First, you can replace some templates globally in the dashboard:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
use EasyCorp\Bundle\EasyAdminBundle\Attribute\AdminDashboard;
use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractDashboardController;

#[AdminDashboard(routePath: '/admin', routeName: 'admin')]
class DashboardController extends AbstractDashboardController
{
    // ...

    public function configureCrud(): Crud
    {
        return Crud::new()
            // ...

            // the first argument is the "template name", which is the same as the
            // Twig path but without the `@EasyAdmin/` prefix
            ->overrideTemplate('label/null', 'admin/labels/my_null_label.html.twig')

            ->overrideTemplates([
                'crud/index' => 'admin/pages/index.html.twig',
                'crud/field/textarea' => 'admin/fields/dynamic_textarea.html.twig',
            ])
        ;
    }
}

You can also replace templates per CRUD controller (this overrides any change done in the dashboard):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace App\Controller\Admin;

use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractCrudController;

class ProductCrudController extends AbstractCrudController
{
    // ...

    public function configureCrud(Crud $crud): Crud
    {
        return $crud
            // ...

            ->overrideTemplate('crud/layout', 'admin/advanced_layout.html.twig')

            ->overrideTemplates([
                'crud/field/text' => 'admin/product/field_id.html.twig',
                'label/null' => 'admin/labels/null_product.html.twig',
            ])
        ;
    }
}

Fields And Actions Templates

Each field (and each action) defines a setTemplatePath() method to set the Twig template used to render that specific field (or action):

1
2
3
4
5
6
7
8
9
TextField::new('...', '...')
    // ...
    ->setTemplatePath('custom_fields/text.html.twig');

// ...

Action::new('...', '...')
    // ...
    ->setTemplatePath('admin/actions/my_custom_action.html.twig');

The setTemplatePath() method only applies to fields displayed on the index and detail pages. Read the next section to learn how to customize fields in the new and edit pages, which use Symfony forms.

Form Field Templates

EasyAdmin provides a ready-to-use form theme based on Bootstrap 5. Dashboards and CRUD controllers define addFormTheme(string $themePath) and setFormThemes(array $themePaths) methods so you can customize individual form fields using your own form theme.

Tip

EasyAdmin's form theme also works for regular Symfony forms not built with EasyAdmin fields. This is useful to make the forms rendered on your own backend pages look exactly like the rest of the backend forms. See how to render Symfony forms in custom pages.

Imagine a form field where you want to include a <a> element that links to additional information. If the field is called title and belongs to a Product entity, the configuration would look like this:

1
2
3
4
5
TextField::new('title')
    // ...
    ->setFormTypeOptions([
        'block_name' => 'custom_title',
    ]);

The next step is to define the template fragment used by that field, which requires to know the form fragment naming rules defined by Symfony:

1
2
3
4
5
6
7
8
{# templates/admin/form.html.twig #}
{# note that the Twig block name starts with an uppercase letter
   ('_Product_...' instead of '_product_...') because the first part
   of the block name is the unmodified entity name #}
{% block _Product_custom_title_widget %}
    {# ... #}
    <a href="...">More information</a>
{% endblock %}

Finally, add this custom theme to the list of themes used to render backend forms:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
namespace App\Controller\Admin;

use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractCrudController;

class ProductCrudController extends AbstractCrudController
{
    // ...

    public function configureCrud(Crud $crud): Crud
    {
        return $crud
            // ...

            // don't forget to add EasyAdmin's form theme at the end of the list
            // (otherwise you'll lose all the styles for the rest of form fields)
            ->setFormThemes(['admin/form.html.twig', '@EasyAdmin/crud/form_theme.html.twig'])
        ;
    }
}

Note

You can also override the form widget by using the original field name. In the example above it would look like this: {% block _Product_title_widget %}. The full syntax is: {% block _<Entity name>_<Field name>_widget %}.

Using EasyAdmin Twig Components

EasyAdmin uses Twig Components to render many parts of its interface. These components are registered under the ea: prefix and you can also use them in your own admin templates (e.g. when overriding backend templates or creating custom pages):

1
<twig:ea:Badge variant="success">Published</twig:ea:Badge>

Read the Twig Components reference to learn about all the available components (buttons, badges, icons, modals, dropdown menus, etc.) with practical examples of how to use them.

Customizing Flash Messages

EasyAdmin displays the flash messages added by your application using the ea:Alert component. Flash messages are usually plain strings, which are translated using the translation domain configured in the dashboard:

1
$this->addFlash('success', 'post.published');

If you want to customize the rendered alert, pass an array with a mandatory message key and optional title and icon keys:

1
2
3
4
5
$this->addFlash('success', [
    'message' => 'post.published',
    'title' => 'post.published.title',
    'icon' => 'fa-circle-check',
]);

The message and title values are translated like plain string flash messages; the icon value accepts the same values as the ea:Icon component (icon names from the icon set configured in the backend).

Adding Custom Web Assets

Use the configureAssets() method in the dashboard and/or the CRUD controllers to add your own CSS and JavaScript files:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
namespace App\Controller\Admin;

use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractCrudController;

class ProductCrudController extends AbstractCrudController
{
    // ...

    public function configureAssets(Assets $assets): Assets
    {
        return $assets
            // imports the given entrypoint defined in the importmap.php file of AssetMapper
            // it's equivalent to adding this inside the <head> element:
            // {{ importmap('admin') }}
            ->addAssetMapperEntry('admin')
            // you can also import multiple entries
            // it's equivalent to calling {{ importmap(['app', 'admin']) }}
            ->addAssetMapperEntry('app', 'admin')

            // adds the CSS and JS assets associated to the given Webpack Encore entry
            // it's equivalent to adding these inside the <head> element:
            // {{ encore_entry_link_tags('...') }} and {{ encore_entry_script_tags('...') }}
            ->addWebpackEncoreEntry('admin-app')

            // adds the CSS and JS assets associated to the given Symfony Reprise entry
            // it's equivalent to adding these inside the <head> element:
            // {{ reprise_entry_link_tags('...') }} and {{ reprise_entry_script_tags('...') }}
            ->addRepriseEntry('admin-app')

            // it's equivalent to adding this inside the <head> element:
            // <link rel="stylesheet" href="{{ asset('...') }}">
            ->addCssFile('build/admin.css')
            ->addCssFile('https://example.org/css/admin2.css')

            // it's equivalent to adding this inside the <head> element:
            // <script src="{{ asset('...') }}"></script>
            ->addJsFile('build/admin.js')
            ->addJsFile('https://example.org/js/admin2.js')

            // use these generic methods to add any code before </head> or </body>
            // the contents are included "as is" in the rendered page (without escaping them)
            ->addHtmlContentToHead('<link rel="dns-prefetch" href="https://assets.example.com">')
            ->addHtmlContentToBody('<script> ... </script>')
            ->addHtmlContentToBody('<!-- generated at '.time().' -->')
        ;
    }
}

If you need to customize the HTML attributes or other features of the <link> and <script> tags, pass an Asset object to the addCssFile(), addJsFile(), addWebpackEncoreEntry() and addRepriseEntry() methods:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
use EasyCorp\Bundle\EasyAdminBundle\Config\Asset;
// ...

return $assets
    ->addCssFile(Asset::new('build/admin.css')->preload()->nopush())
    ->addCssFile(Asset::new('build/admin-print.css')->htmlAttr('media', 'print'))

    ->addJsFile(Asset::new('build/admin.js')->defer())
    ->addJsFile(Asset::new('build/admin.js')->preload())
    ->addJsFile(Asset::new('build/admin.js')->htmlAttr('referrerpolicy', 'strict-origin'))

    ->addWebpackEncoreEntry(Asset::new('admin-app')->webpackEntrypointName('...'))

    // Symfony Reprise entries only support defining the Symfony Asset package
    // that they belong to; the HTML attributes of their <link> and <script>
    // tags are configured globally in the Symfony Reprise bundle configuration
    ->addRepriseEntry(Asset::new('admin-app')->reprisePackageName('...'))

    // adding full Asset objects for AssetMapper entries work too, but it's
    // useless because entries can't define any property, only their name
    ->addAssetMapperEntry(Asset::new('admin'))

    ->addCssFile(Asset::new('build/admin-detail.css')->onlyOnDetail())
    ->addJsFile(Asset::new('build/admin.js')->onlyWhenCreating())
    ->addWebpackEncoreEntry(Asset::new('admin-app')->ignoreOnForm())

    // you can also define the Symfony Asset package which the asset belongs to
    ->addCssFile(Asset::new('some-path/foo.css')->package('legacy_assets'))
;

Tip

Fields can also add CSS and JavaScript assets to the rendered pages. Read this section to learn how.

Note

If you want to unload the default assets included by EasyAdmin, override the default layout.html.twig template and empty the head_stylesheets and head_javascript Twig blocks.

Customizing the Backend Design

The design of the backend is created with lots of CSS variables. This makes it easier to customize it to your own needs. They are defined in two layers:

  • Design tokens are the few global knobs the rest of the design derives from. They live in vendor/easycorp/easyadmin-bundle/assets/css/easyadmin-theme/design-tokens.css. Changing one of them re-themes the whole backend at once.
  • Theme variables are the hundreds of specific values built on top of those tokens (the sidebar background, the table border color, etc.). They live in vendor/easycorp/easyadmin-bundle/assets/css/easyadmin-theme/variables-theme.css.

Start with the design tokens, because each one changes many things consistently:

1
2
3
4
5
6
7
8
9
10
11
12
13
/* public/css/admin.css */
:root,
.ea-dark-scheme {
    /* the accent color of buttons, links, switches, etc. Pick one with
       enough contrast on white, because it is also used for link text */
    --ea-primary: #15803d;
    /* the base of the spacing scale; increase it for a roomier backend,
       decrease it for a denser one. All paddings, margins, gaps and the
       height of buttons and switches are multiples of this value */
    --ea-spacing: 0.25rem;
    /* the base of the border radius scale; set it to 0 for square corners */
    --ea-radius: 0.25rem;
}

Tip

If your primary color is light (e.g. a yellow), the white text drawn on top of it (button labels, etc.) becomes unreadable. Set --ea-primary-foreground to a dark color in that case:

1
2
3
4
:root, .ea-dark-scheme {
    --ea-primary: #facc15;
    --ea-primary-foreground: #1a1a1a;
}

Caution

Override the design tokens on :root, .ea-dark-scheme, not just on :root. The backend applies its dark scheme with a class on the <body> element, and it defines its own value of these tokens there, so a :root-only override applies to the light scheme but is ignored in dark mode. Use separate rules if you want a different value per scheme.

Then override any of the more specific theme variables the same way:

1
2
3
4
5
6
7
8
9
/* public/css/admin.css */
:root {
    /* make the backend contents as wide as the browser window */
    --body-max-width: 100%;
    /* change the background color of the <body> */
    --body-bg: #f5f5f5;
    /* make the base font size smaller */
    --font-size-base: 13px;
}

Then, load this CSS file in your dashboard and/or resource admin:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use EasyCorp\Bundle\EasyAdminBundle\Attribute\AdminDashboard;
use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractDashboardController;

#[AdminDashboard(routePath: '/admin', routeName: 'admin')]
class DashboardController extends AbstractDashboardController
{
    // ...

    public function configureAssets(): Assets
    {
        return Assets::new()->addCssFile('css/admin.css');
    }
}

Tip

The backend styles some Bootstrap components by mapping Bootstrap's own --bs-* variables onto the EasyAdmin ones (at the end of variables-theme.css). If some Bootstrap style resists your changes, override the relevant --bs-* variable in your own CSS file.

CSS Cascade Layers

In addition to redefining CSS variables, you can override any style with your own CSS rules. All backend styles are assigned to CSS cascade layers: vendor for third-party styles (Bootstrap, Font Awesome, etc.) and ea for the EasyAdmin styles (with ea.tokens, ea.base, ea.components and ea.utilities sublayers).

Unlayered CSS always wins over layered CSS, so any rule in your own CSS files overrides the backend styles, no matter its specificity or loading order. You don't need !important flags or artificially specific selectors:

1
2
3
4
/* public/css/admin.css */
.sidebar {
    background: linear-gradient(180deg, #1e293b, #0f172a);
}

CSS Selectors

The <body> element of every backend page includes different id and class attributes to help you target your own styles. The id follows this pattern:

Page <body> ID attribute
detail ea-detail-<entity_name>-<entity_id>
edit ea-edit-<entity_name>-<entity_id>
index ea-index-<entity_name>
new ea-new-<entity_name>

If you are editing for example the element with id = 200 of the User entity, the <body> of that page will be <body id="easyadmin-edit-User-200" ...>.

The pattern of the class attribute is different because it applies several CSS classes:

Page <body> CSS class
detail ea-detail ea-detail-<entity_name>
edit ea-edit ea-edit-<entity_name>
index ea-index ea-index-<entity_name>
new ea-new ea-new-<entity_name>

If you are displaying for example the listing of User entity elements, the <body> of that page will be <body class="ea index index-User" ...>.

Managing the Backend Assets with Webpack

EasyAdmin uses Webpack (via Symfony's Webpack Encore) to manage its CSS and JavaScript assets. This bundle provides both the source files and the compiled versions of all assets, so you don't have to install Webpack to use this bundle.

However, if you want total control over the backend styles, you can use Webpack to integrate the SCSS and JavaScript source files provided in the assets/ directory. The only limitation is that EasyAdmin doesn't use Webpack Encore yet when loading the assets, so you can't use features like versioning. This will be fixed in future versions.

Content Security Policy (CSP) Support

Content Security Policy (CSP) is a security feature that helps prevent cross-site scripting (XSS) and other code injection attacks. When your application uses strict CSP headers, all inline scripts and dynamically loaded scripts must include a cryptographic nonce to be executed by the browser.

EasyAdmin fully supports CSP nonces. First, install and configure NelmioSecurityBundle in your application. Then, EasyAdmin will automatically detect the csp_nonce() Twig function and add the nonce attribute to all its script tags.

Using CSP Nonces in Custom Templates

If you override EasyAdmin templates and add your own <script> tags, use the {% guard %} Twig tag to conditionally include the nonce. This ensures your templates work both with and without NelmioSecurityBundle:

1
2
3
4
5
{% guard function csp_nonce %}
    <script src="{{ asset('js/custom.js') }}" nonce="{{ csp_nonce('script') }}"></script>
{% else %}
    <script src="{{ asset('js/custom.js') }}"></script>
{% endguard %}

The {% guard function csp_nonce %} syntax checks if the csp_nonce() function is available before using it, allowing graceful fallback when NelmioSecurityBundle is not installed.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version