1Mojolicious(3) User Contributed Perl Documentation Mojolicious(3)
2
6 Mojolicious - Real-time web framework
7
9 # Application
10 package MyApp;
11 use Mojo::Base 'Mojolicious', -signatures;
12 # Route
14 sub startup ($self) {
15 $self->routes->get('/hello')->to('foo#hello');
16 }
17 # Controller
19 package MyApp::Controller::Foo;
20 use Mojo::Base 'Mojolicious::Controller', -signatures;
21 # Action
23 sub hello ($self) {
24 $self->render(text => 'Hello World!');
25 }
26
28 An amazing real-time web framework built on top of the powerful Mojo
29 web development toolkit. With support for RESTful routes, plugins,
30 commands, Perl-ish templates, content negotiation, session management,
31 form validation, testing framework, static file server, "CGI"/"PSGI"
32 detection, first class Unicode support and much more for you to
33 discover.
34 Take a look at our excellent documentation in Mojolicious::Guides!
36
38 Mojolicious will emit the following hooks in the listed order.
39 before_command
41 Emitted right before the application runs a command through the command
42 line interface.
43 $app->hook(before_command => sub ($command, $args) {...});
45 Useful for reconfiguring the application before running a command or to
47 modify the behavior of a command. (Passed the command object and the
48 command arguments)
49 before_server_start
51 Emitted right before the application server is started, for web servers
52 that support it, which includes all the built-in ones.
53 $app->hook(before_server_start => sub ($server, $app) {...});
55 Useful for reconfiguring application servers dynamically or collecting
57 server diagnostics information. (Passed the server and application
58 objects)
59 after_build_tx
61 Emitted right after the transaction is built and before the HTTP
62 request gets parsed.
63 $app->hook(after_build_tx => sub ($tx, $app) {...});
65 This is a very powerful hook and should not be used lightly, it makes
67 some rather advanced features such as upload progress bars possible.
68 Note that this hook will not work for embedded applications, because
69 only the host application gets to build transactions. (Passed the
70 transaction and application objects)
71 around_dispatch
73 Emitted right after a new request has been received and wraps around
74 the whole dispatch process, so you have to manually forward to the next
75 hook if you want to continue the chain. Default exception handling with
76 "reply->exception" in Mojolicious::Plugin::DefaultHelpers is the first
77 hook in the chain and a call to "dispatch" the last, yours will be in
78 between.
79 $app->hook(around_dispatch => sub ($next, $c) {
81 ...
82 $next->();
83 ...
84 });
85 This is a very powerful hook and should not be used lightly, it allows
87 you to, for example, customize application-wide exception handling,
88 consider it the sledgehammer in your toolbox. (Passed a callback
89 leading to the next hook and the default controller object)
90 before_dispatch
92 Emitted right before the static file server and router start their
93 work.
94 $app->hook(before_dispatch => sub ($c) {...});
96 Very useful for rewriting incoming requests and other preprocessing
98 tasks. (Passed the default controller object)
99 after_static
101 Emitted after a static file response has been generated by the static
102 file server.
103 $app->hook(after_static => sub ($c) {...});
105 Mostly used for post-processing static file responses. (Passed the
107 default controller object)
108 before_routes
110 Emitted after the static file server determined if a static file should
111 be served and before the router starts its work.
112 $app->hook(before_routes => sub ($c) {...});
114 Mostly used for custom dispatchers and collecting metrics. (Passed the
116 default controller object)
117 around_action
119 Emitted right before an action gets executed and wraps around it, so
120 you have to manually forward to the next hook if you want to continue
121 the chain. Default action dispatching is the last hook in the chain,
122 yours will run before it.
123 $app->hook(around_action => sub ($next, $c, $action, $last) {
125 ...
126 return $next->();
127 });
128 This is a very powerful hook and should not be used lightly, it allows
130 you for example to pass additional arguments to actions or handle
131 return values differently. Note that this hook can trigger more than
132 once for the same request if there are nested routes. (Passed a
133 callback leading to the next hook, the current controller object, the
134 action callback and a flag indicating if this action is an endpoint)
135 before_render
137 Emitted before content is generated by the renderer. Note that this
138 hook can trigger out of order due to its dynamic nature, and with
139 embedded applications will only work for the application that is
140 rendering.
141 $app->hook(before_render => sub ($c, $args) {...});
143 Mostly used for pre-processing arguments passed to the renderer.
145 (Passed the current controller object and the render arguments)
146 after_render
148 Emitted after content has been generated by the renderer that will be
149 assigned to the response. Note that this hook can trigger out of order
150 due to its dynamic nature, and with embedded applications will only
151 work for the application that is rendering.
152 $app->hook(after_render => sub ($c, $output, $format) {...});
154 Mostly used for post-processing dynamically generated content. (Passed
156 the current controller object, a reference to the content and the
157 format)
158 after_dispatch
160 Emitted in reverse order after a response has been generated. Note that
161 this hook can trigger out of order due to its dynamic nature, and with
162 embedded applications will only work for the application that is
163 generating the response.
164 $app->hook(after_dispatch => sub ($c) {...});
166 Useful for rewriting outgoing responses and other post-processing
168 tasks. (Passed the current controller object)
169
171 Mojolicious implements the following attributes.
172 commands
174 my $commands = $app->commands;
175 $app = $app->commands(Mojolicious::Commands->new);
176 Command line interface for your application, defaults to a
178 Mojolicious::Commands object.
179 # Add another namespace to load commands from
181 push @{$app->commands->namespaces}, 'MyApp::Command';
182 controller_class
184 my $class = $app->controller_class;
185 $app = $app->controller_class('Mojolicious::Controller');
186 Class to be used for the default controller, defaults to
188 Mojolicious::Controller. Note that this class needs to have already
189 been loaded before the first request arrives.
190 exception_format
192 my $format = $app->exception_format;
193 $app = $app->exception_format('txt');
194 Format for HTTP exceptions ("html", "json", or "txt"), defaults to
196 "html".
197 home
199 my $home = $app->home;
200 $app = $app->home(Mojo::Home->new);
201 The home directory of your application, defaults to a Mojo::Home object
203 which stringifies to the actual path.
204 # Portably generate path relative to home directory
206 my $path = $app->home->child('data', 'important.txt');
207 log
209 my $log = $app->log;
210 $app = $app->log(Mojo::Log->new);
211 The logging layer of your application, defaults to a Mojo::Log object.
213 The level will default to either the "MOJO_LOG_LEVEL" environment
214 variable, "trace" if the "mode" is "development", or "info" otherwise.
215 All messages will be written to "STDERR" by default.
216 # Log debug message
218 $app->log->debug('It works');
219 max_request_size
221 my $max = $app->max_request_size;
222 $app = $app->max_request_size(16777216);
223 Maximum request size in bytes, defaults to the value of
225 "max_message_size" in Mojo::Message. Setting the value to 0 will allow
226 requests of indefinite size. Note that increasing this value can also
227 drastically increase memory usage, should you for example attempt to
228 parse an excessively large request body with the methods "dom" in
229 Mojo::Message or "json" in Mojo::Message.
230 mode
232 my $mode = $app->mode;
233 $app = $app->mode('production');
234 The operating mode for your application, defaults to a value from the
236 "MOJO_MODE" and "PLACK_ENV" environment variables or "development".
237 moniker
239 my $moniker = $app->moniker;
240 $app = $app->moniker('foo_bar');
241 Moniker of this application, often used as default filename for
243 configuration files and the like, defaults to decamelizing the
244 application class with "decamelize" in Mojo::Util.
245 plugins
247 my $plugins = $app->plugins;
248 $app = $app->plugins(Mojolicious::Plugins->new);
249 The plugin manager, defaults to a Mojolicious::Plugins object. See the
251 "plugin" method below if you want to load a plugin.
252 # Add another namespace to load plugins from
254 push @{$app->plugins->namespaces}, 'MyApp::Plugin';
255 preload_namespaces
257 my $namespaces = $app->preload_namespaces;
258 $app = $app->preload_namespaces(['MyApp::Controller']);
259 Namespaces to preload classes from during application startup.
261 renderer
263 my $renderer = $app->renderer;
264 $app = $app->renderer(Mojolicious::Renderer->new);
265 Used to render content, defaults to a Mojolicious::Renderer object. For
267 more information about how to generate content see
268 Mojolicious::Guides::Rendering.
269 # Enable compression
271 $app->renderer->compress(1);
272 # Add another "templates" directory
274 push @{$app->renderer->paths}, '/home/sri/templates';
275 # Add another "templates" directory with higher precedence
277 unshift @{$app->renderer->paths}, '/home/sri/themes/blue/templates';
278 # Add another class with templates in DATA section
280 push @{$app->renderer->classes}, 'Mojolicious::Plugin::Fun';
281 routes
283 my $routes = $app->routes;
284 $app = $app->routes(Mojolicious::Routes->new);
285 The router, defaults to a Mojolicious::Routes object. You use this in
287 your startup method to define the url endpoints for your application.
288 # Add routes
290 my $r = $app->routes;
291 $r->get('/foo/bar')->to('test#foo', title => 'Hello Mojo!');
292 $r->post('/baz')->to('test#baz');
293 # Add another namespace to load controllers from
295 push @{$app->routes->namespaces}, 'MyApp::MyController';
296 secrets
298 my $secrets = $app->secrets;
299 $app = $app->secrets([$bytes]);
300 Secret passphrases used for signed cookies and the like, defaults to
302 the "moniker" of this application, which is not very secure, so you
303 should change it!!! As long as you are using the insecure default there
304 will be debug messages in the log file reminding you to change your
305 passphrase. Only the first passphrase is used to create new signatures,
306 but all of them for verification. So you can increase security without
307 invalidating all your existing signed cookies by rotating passphrases,
308 just add new ones to the front and remove old ones from the back.
309 # Rotate passphrases
311 $app->secrets(['new_passw0rd', 'old_passw0rd', 'very_old_passw0rd']);
312 sessions
314 my $sessions = $app->sessions;
315 $app = $app->sessions(Mojolicious::Sessions->new);
316 Signed cookie based session manager, defaults to a
318 Mojolicious::Sessions object. You can usually leave this alone, see
319 "session" in Mojolicious::Controller for more information about working
320 with session data.
321 # Change name of cookie used for all sessions
323 $app->sessions->cookie_name('mysession');
324 # Disable SameSite feature
326 $app->sessions->samesite(undef);
327 static
329 my $static = $app->static;
330 $app = $app->static(Mojolicious::Static->new);
331 For serving static files from your "public" directories, defaults to a
333 Mojolicious::Static object.
334 # Serve static files only with a "/static" prefix
336 $app->static->prefix('/static');
337 # Add another "public" directory
339 push @{$app->static->paths}, '/home/sri/public';
340 # Add another "public" directory with higher precedence
342 unshift @{$app->static->paths}, '/home/sri/themes/blue/public';
343 # Add another class with static files in DATA section
345 push @{$app->static->classes}, 'Mojolicious::Plugin::Fun';
346 # Remove built-in favicon
348 delete $app->static->extra->{'favicon.ico'};
349 types
351 my $types = $app->types;
352 $app = $app->types(Mojolicious::Types->new);
353 Responsible for connecting file extensions with MIME types, defaults to
355 a Mojolicious::Types object.
356 # Add custom MIME type
358 $app->types->type(twt => 'text/tweet');
359 ua
361 my $ua = $app->ua;
362 $app = $app->ua(Mojo::UserAgent->new);
363 A full featured HTTP user agent for use in your applications, defaults
365 to a Mojo::UserAgent object.
366 # Perform blocking request
368 say $app->ua->get('example.com')->result->body;
369 validator
371 my $validator = $app->validator;
372 $app = $app->validator(Mojolicious::Validator->new);
373 Validate values, defaults to a Mojolicious::Validator object.
375 # Add validation check
377 $app->validator->add_check(foo => sub ($v, $name, $value) {
378 return $value ne 'foo';
379 });
380 # Add validation filter
382 $app->validator->add_filter(quotemeta => sub ($v, $name, $value) {
383 return quotemeta $value;
384 });
385
387 Mojolicious inherits all methods from Mojo::Base and implements the
388 following new ones.
389 build_controller
391 my $c = $app->build_controller;
392 my $c = $app->build_controller(Mojo::Transaction::HTTP->new);
393 my $c = $app->build_controller(Mojolicious::Controller->new);
394 Build default controller object with "controller_class".
396 # Render template from application
398 my $foo = $app->build_controller->render_to_string(template => 'foo');
399 build_tx
401 my $tx = $app->build_tx;
402 Build Mojo::Transaction::HTTP object and emit "after_build_tx" hook.
404 config
406 my $hash = $app->config;
407 my $foo = $app->config('foo');
408 $app = $app->config({foo => 'bar', baz => 23});
409 $app = $app->config(foo => 'bar', baz => 23);
410 Application configuration.
412 # Remove value
414 my $foo = delete $app->config->{foo};
415 # Assign multiple values at once
417 $app->config(foo => 'test', bar => 23);
418 defaults
420 my $hash = $app->defaults;
421 my $foo = $app->defaults('foo');
422 $app = $app->defaults({foo => 'bar', baz => 23});
423 $app = $app->defaults(foo => 'bar', baz => 23);
424 Default values for "stash" in Mojolicious::Controller, assigned for
426 every new request.
427 # Remove value
429 my $foo = delete $app->defaults->{foo};
430 # Assign multiple values at once
432 $app->defaults(foo => 'test', bar => 23);
433 dispatch
435 $app->dispatch(Mojolicious::Controller->new);
436 The heart of every Mojolicious application, calls the "static" and
438 "routes" dispatchers for every request and passes them a
439 Mojolicious::Controller object.
440 handler
442 $app->handler(Mojo::Transaction::HTTP->new);
443 $app->handler(Mojolicious::Controller->new);
444 Sets up the default controller and emits the "around_dispatch" hook for
446 every request.
447 helper
449 $app->helper(foo => sub {...});
450 Add or replace a helper that will be available as a method of the
452 controller object and the application object, as well as a function in
453 "ep" templates. For a full list of helpers that are available by
454 default see Mojolicious::Plugin::DefaultHelpers and
455 Mojolicious::Plugin::TagHelpers.
456 # Helper
458 $app->helper(cache => sub { state $cache = {} });
459 # Application
461 $app->cache->{foo} = 'bar';
462 my $result = $app->cache->{foo};
463 # Controller
465 $c->cache->{foo} = 'bar';
466 my $result = $c->cache->{foo};
467 # Template
469 % cache->{foo} = 'bar';
470 %= cache->{foo}
471 hook
473 $app->hook(after_dispatch => sub {...});
474 Extend Mojolicious with hooks, which allow code to be shared with all
476 requests indiscriminately, for a full list of available hooks see
477 "HOOKS".
478 # Dispatchers will not run if there's already a response code defined
480 $app->hook(before_dispatch => sub ($c) {
481 $c->render(text => 'Skipped static file server and router!')
482 if $c->req->url->path->to_route =~ /do_not_dispatch/;
483 });
484 new
486 my $app = Mojolicious->new;
487 my $app = Mojolicious->new(moniker => 'foo_bar');
488 my $app = Mojolicious->new({moniker => 'foo_bar'});
489 Construct a new Mojolicious application and call "startup". Will
491 automatically detect your home directory. Also sets up the renderer,
492 static file server, a default set of plugins and an "around_dispatch"
493 hook with the default exception handling.
494 plugin
496 $app->plugin('some_thing');
497 $app->plugin('some_thing', foo => 23);
498 $app->plugin('some_thing', {foo => 23});
499 $app->plugin('SomeThing');
500 $app->plugin('SomeThing', foo => 23);
501 $app->plugin('SomeThing', {foo => 23});
502 $app->plugin('MyApp::Plugin::SomeThing');
503 $app->plugin('MyApp::Plugin::SomeThing', foo => 23);
504 $app->plugin('MyApp::Plugin::SomeThing', {foo => 23});
505 Load a plugin, for a full list of example plugins included in the
507 Mojolicious distribution see "PLUGINS" in Mojolicious::Plugins.
508 server
510 $app->server(Mojo::Server->new);
511 Emits the "before_server_start" hook.
513 start
515 $app->start;
516 $app->start(@ARGV);
517 Start the command line interface for your application. For a full list
519 of commands that are available by default see "COMMANDS" in
520 Mojolicious::Commands. Note that the options "-h"/"--help", "--home"
521 and "-m"/"--mode", which are shared by all commands, will be parsed
522 from @ARGV during compile time.
523 # Always start daemon
525 $app->start('daemon', '-l', 'http://*:8080');
526 startup
528 $app->startup;
529 This is your main hook into the application, it will be called at
531 application startup. Meant to be overloaded in a subclass.
532 sub startup ($self) {...}
534 warmup
536 $app->warmup;
537 Preload classes from "preload_namespaces" for future use.
539
541 In addition to the "ATTRIBUTES" and "METHODS" above you can also call
542 helpers on Mojolicious objects. This includes all helpers from
543 Mojolicious::Plugin::DefaultHelpers and
544 Mojolicious::Plugin::TagHelpers. Note that application helpers are
545 always called with a new default controller object, so they can't
546 depend on or change controller state, which includes request, response
547 and stash.
548 # Call helper
550 say $app->dumper({foo => 'bar'});
551 # Longer version
553 say $app->build_controller->helpers->dumper({foo => 'bar'});
554
556 The Mojolicious distribution includes a few files with different
557 licenses that have been bundled for internal use.
558 Mojolicious Artwork
560 Copyright (C) 2010-2023, Sebastian Riedel.
561 Licensed under the CC-SA License, Version 4.0
563 <http://creativecommons.org/licenses/by-sa/4.0>.
564 jQuery
566 Copyright (C) jQuery Foundation.
567 Licensed under the MIT License,
569 <http://creativecommons.org/licenses/MIT>.
570 highlight.js
572 Copyright (C) 2006, Ivan Sagalaev.
573 Licensed under the BSD License,
575 <https://github.com/highlightjs/highlight.js/blob/master/LICENSE>.
576 Bootstrap
578 Copyright 2011-2020 The Bootstrap Authors.
579 Copyright 2011-2020 Twitter, Inc.
580 Licensed under the MIT License,
582 <http://creativecommons.org/licenses/MIT>.
583 Font Awesome
585 Licensed under the CC-BY License, Version 4.0
586 <https://creativecommons.org/licenses/by/4.0/> and SIL OFL, Version 1.1
587 <https://opensource.org/licenses/OFL-1.1>.
588
590 Every major release of Mojolicious has a code name, these are the ones
591 that have been used in the past.
592 9.0, "Waffle" (U+1F9C7)
594 8.0, "Supervillain" (U+1F9B9)
596 7.0, "Doughnut" (U+1F369)
598 6.0, "Clinking Beer Mugs" (U+1F37B)
600 5.0, "Tiger Face" (U+1F42F)
602 4.0, "Top Hat" (U+1F3A9)
604 3.0, "Rainbow" (U+1F308)
606 2.0, "Leaf Fluttering In Wind" (U+1F343)
608 1.0, "Snowflake" (U+2744)
610
612 • Stix <https://stix.no> sponsored the creation of the Mojolicious logo
613 (designed by Nicolai Graesdal) and transferred its copyright to
614 Sebastian Riedel.
615 • Some of the work on this distribution has been sponsored by The Perl
617 Foundation <https://www.perlfoundation.org>.
618
620 Mojolicious is an open source project that relies on the tireless
621 support of its contributors.
622 Project Founder
624 Sebastian Riedel, "kraih@mojolicious.org"
625 Core Developers
627 Current voting members of the core team in alphabetical order:
628 CandyAngel, "candyangel@mojolicious.org"
630 Christopher Rasch-Olsen Raa, "christopher@mojolicious.org"
632 Dan Book, "grinnz@mojolicious.org"
634 Jan Henning Thorsen, "batman@mojolicious.org"
636 Joel Berger, "jberger@mojolicious.org"
638 Marcus Ramberg, "marcus@mojolicious.org"
640 The following members of the core team are currently on hiatus:
642 Abhijit Menon-Sen, "ams@cpan.org"
644 Glen Hinkle, "tempire@cpan.org"
646 Contributors
648 In alphabetical order:
649 Adam Kennedy
651 Adriano Ferreira
653 Al Newkirk
655 Alex Efros
657 Alex Salimon
659 Alexander Karelas
661 Alexey Likhatskiy
663 Anatoly Sharifulin
665 Andre Parker
667 Andre Vieth
669 Andreas Guldstrand
671 Andreas Jaekel
673 Andreas Koenig
675 Andrew Fresh
677 Andrew Nugged
679 Andrey Khozov
681 Andrey Kuzmin
683 Andy Grundman
685 Andy Lester
687 Aristotle Pagaltzis
689 Ashley Dev
691 Ask Bjoern Hansen
693 Audrey Tang
695 Ben Tyler
697 Ben van Staveren
699 Benjamin Erhart
701 Bernhard Graf
703 Breno G. de Oliveira
705 Brian Duggan
707 Brian Medley
709 Burak Gursoy
711 Ch Lamprecht
713 Charlie Brady
715 Chas. J. Owens IV
717 Chase Whitener
719 Chris Scheller
721 Christian Hansen
723 chromatic
725 Curt Tilmes
727 Daniel Kimsey
729 Daniel Mantovani
731 Danijel Tasov
733 Dagfinn Ilmari Manns�ker
735 Danny Thomas
737 David Davis
739 David Webb
741 Diego Kuperman
743 Dmitriy Shalashov
745 Dmitry Konstantinov
747 Dominik Jarmulowicz
749 Dominique Dumont
751 Dotan Dimet
753 Douglas Christopher Wilson
755 Elmar S. Heeb
757 Ettore Di Giacinto
759 Eugen Konkov
761 Eugene Toropov
763 Flavio Poletti
765 Gisle Aas
767 Graham Barr
769 Graham Knop
771 Heiko Jansen
773 Henry Tang
775 Hideki Yamamura
777 Hiroki Toyokawa
779 Ian Goodacre
781 Ilya Chesnokov
783 Ilya Rassadin
785 James Duncan
787 Jan Jona Javorsek
789 Jan Schmidt
791 Jaroslav Muhin
793 Jesse Vincent
795 Johannes Plunien
797 John Kingsley
799 Jonathan Yu
801 Josh Leder
803 Kamen Naydenov
805 Karen Etheridge
807 Kazuhiro Shibuya
809 Kevin Old
811 Kitamura Akatsuki
813 Klaus S. Madsen
815 Knut Arne Bjorndal
817 Lars Balker Rasmussen
819 Lee Johnson
821 Leon Brocard
823 Lukas Mai
825 Magnus Holm
827 Maik Fischer
829 Mark Fowler
831 Mark Grimes
833 Mark Stosberg
835 Martin McGrath
837 Marty Tennison
839 Matt S Trout
841 Matthew Lineen
843 Maksym Komar
845 Maxim Vuets
847 Michael Gregorowicz
849 Michael Harris
851 Michael Jemmeson
853 Mike Magowan
855 Mirko Westermeier
857 Mons Anderson
859 Moritz Lenz
861 Neil Watkiss
863 Nic Sandfield
865 Nils Diewald
867 Oleg Zhelo
869 Olivier Mengue
871 Pascal Gaudette
873 Paul Evans
875 Paul Robins
877 Paul Tomlin
879 Pavel Shaydo
881 Pedro Melo
883 Peter Edwards
885 Pierre-Yves Ritschard
887 Piotr Roszatycki
889 Quentin Carbonneaux
891 Rafal Pocztarski
893 Randal Schwartz
895 Rawley Fowler
897 Richard Elberger
899 Rick Delaney
901 Robert Hicks
903 Robert Rothenberg
905 Robin Lee
907 Roland Lammel
909 Roy Storey
911 Ryan Jendoubi
913 Salvador Fandino
915 Santiago Zarate
917 Sascha Kiefer
919 Scott Wiersdorf
921 Sebastian Paaske Torholm
923 Sergey Zasenko
925 Simon Bertrang
927 Simone Tampieri
929 Shoichi Kaji
931 Shu Cho
933 Skye Shaw
935 Stanis Trendelenburg
937 Stefan Adams
939 Steffen Ullrich
941 Stephan Kulow
943 Stephane Este-Gracias
945 Stevan Little
947 Steve Atkins
949 Tatsuhiko Miyagawa
951 Terrence Brannon
953 Tianon Gravi
955 Tomas Znamenacek
957 Tudor Constantin
959 Ulrich Habel
961 Ulrich Kautz
963 Uwe Voelker
965 Veesh Goldman
967 Viacheslav Tykhanovskyi
969 Victor Engmark
971 Viliam Pucik
973 Wes Cravens
975 William Lindley
977 Yaroslav Korshak
979 Yuki Kimoto
981 Zak B. Elep
983 Zoffix Znet
985
987 Copyright (C) 2008-2023, Sebastian Riedel and others.
988 This program is free software, you can redistribute it and/or modify it
990 under the terms of the Artistic License version 2.0.
991
993 <https://github.com/mojolicious/mojo>, Mojolicious::Guides,
994 <https://mojolicious.org>.
995perl v5.38.0 2023-09-11 Mojolicious(3)