man Catalyst::Manual::Intro () - Introduction to Catalyst


Catalyst::Manual::Intro - Introduction to Catalyst


This is a brief overview of why and how to use Catalyst. It explains how Catalyst works and shows how to get a simple application up and running quickly.

What is Catalyst?

Catalyst is an elegant web application framework, extremely flexible yet extremely simple. It's similar to Ruby on Rails, Spring (Java) and Maypole, upon which it was originally based.


Catalyst follows the Model-View-Controller (MVC) design pattern, allowing you to easily separate concerns, like content, presentation, and flow control, into separate modules. This separation allows you to modify code that handles one concern without affecting code that handles the others. Catalyst promotes the re-use of existing Perl modules that already handle common web application concerns well.

Here's how the M, V, and C map to those concerns, with examples of well-known Perl modules you may want to use for each.

* Model
Access and modify content (data). Class::DBI, Plucene, Net::LDAP...
* View
Present content to the user. Template Toolkit, Mason, HTML::Template...
* Controller
Control the whole request phase, check parameters, dispatch actions, flow control. Catalyst!

If you're unfamiliar with MVC and design patterns, you may want to check out the original book on the subject, Design Patterns, by Gamma, Helm, Johnson, and Vlissides, also known as the Gang of Four (GoF). You can also just Google it. Many, many web application frameworks are based on MVC, including all those listed above.


Catalyst is much more flexible than many other frameworks. We'll talk more about this later, but rest assured you can use your favorite Perl modules with Catalyst.

* Multiple Models, Views, and Controllers
To build a Catalyst application, you handle each type of concern inside special modules called Components. Often this code will be very simple, just calling out to Perl modules like those listed above under MVC. Catalyst handles these components in a very flexible way. Use as many Models, Views, and Controllers as you like, using as many different Perl modules as you like, all in the same application. Want to manipulate multiple databases, and retrieve some data via LDAP? No problem. Want to present data from the same Model using Template Toolkit and PDF::Template? Easy.
* Reuseable Components
Not only does Catalyst promote the re-use of already existing Perl modules, it also allows you to re-use your Catalyst components in multiple Catalyst applications.
* Unrestrained URL-to-Action Dispatching
Catalyst allows you to dispatch any URLs to any application Actions, even through regular expressions! Unlike most other frameworks, it doesn't require mod_rewrite or class and method names in URLs. With Catalyst you register your actions and address them directly. For example:
    sub hello : Global {
        my ( $self, $context ) = @_;
        $context->response->body('Hello World!');
Now http://localhost:3000/hello prints Hello World!.
* Support for CGI, mod_perl, Apache::Request
Use Catalyst::Engine::Apache or Catalyst::Engine::CGI.


The best part is that Catalyst implements all this flexibility in a very simple way.

* Building Block Interface
Components interoperate very smoothly. For example, Catalyst automatically makes a Context object available to every component. Via the context, you can access the request object, share data between components, and control the flow of your application. Building a Catalyst application feels a lot like snapping together toy building blocks, and everything just works.
* Component Auto-Discovery
No need to CWuse all of your components. Catalyst automatically finds and loads them.
* Pre-Built Components for Popular Modules
See Catalyst::Model::CDBI for Class::DBI, or Catalyst::View::TT for Template Toolkit.
* Built-in Test Framework
Catalyst comes with a built-in, lightweight http server and test framework, making it easy to test applications from the command line.
* Helper Scripts
Catalyst provides helper scripts to quickly generate running starter code for components and unit tests. See Catalyst::Helper.


Here's how to install Catalyst and get a simple application up and running, using the helper scripts described above.


    $ perl -MCPAN -e 'install Task::Catalyst'


    $ MyApp
    # output omitted
    $ cd MyApp
    $ script/ controller Library::Login


    $ script/

Now visit these locations with your favorite browser or user agent to see Catalyst in action:


Dead easy!

How It Works

Let's see how Catalyst works, by taking a closer look at the components and other parts of a Catalyst application.

Application Class

In addition to the Model, View, and Controller components, there's a single class that represents your application itself. This is where you configure your application, load plugins, define application-wide actions, and extend Catalyst.

    package MyApp;

    use strict;
    use Catalyst qw/-Debug/;

        name => 'My Application',

        # You can put anything else you want in here:
        my_configuration_variable => 'something',

    sub default : Private {
        my ( $self, $context ) = @_;
        $context->response->body('Catalyst rocks!');


For most applications, Catalyst requires you to define only one config parameter:

* name
Name of your application.

Optionally, you can specify a root parameter for templates and static data. If omitted, Catalyst will try to auto-detect the directory's location. You can define as many parameters as you want for plugins or whatever you need. You can access them anywhere in your application via CW$context->config->{$param_name}.


Catalyst automatically blesses a Context object into your application class and makes it available everywhere in your application. Use the Context to directly interact with Catalyst and glue your Components together. For example, if you need to use the Context from within a Template Toolkit template, it's already there:

    <h1>Welcome to [% %]!</h1>

As illustrated in our URL-to-Action dispatching example, the Context is always the second method parameter, behind the Component object reference or class name itself. Previously we called it CW$context for clarity, but most Catalyst developers just call it CW$c:

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->res->body('Hello World!');

The Context contains several important objects:

* Catalyst::Request
    $c->req # alias
The request object contains all kinds of request-specific information, like query parameters, cookies, uploads, headers, and more.
* Catalyst::Response
    $c->res # alias
The response is like the request, but contains just response-specific information.
    $c->res->body('Hello World');
* Catalyst::Config
* Catalyst::Log
    $c->log->debug('Something happened');
    $c->log->info('Something you should know');
* Stash
    $c->stash->{foo} = 'bar';

The last of these, the stash, is a universal hash for sharing data among application components. For an example, we return to our 'hello' action:

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->stash->{message} = 'Hello World!';

    sub show_message : Private {
        my ( $self, $c ) = @_;
        $c->res->body( $c->stash->{message} );

Note that the stash should be used only for passing data in an individual request cycle; it gets cleared at a new request. If you need to maintain more persistent data, use a session.


A Catalyst controller is defined by its actions. An action is a sub with a special attribute. You've already seen some examples of actions in this document. The URL (for example http://localhost.3000/foo/bar) consists of two parts, the base (http://localhost:3000/ in this example) and the path (foo/bar). Please note that the trailing slash after the hostname[:port] always belongs to base and not to the action.

Catalyst supports several types of actions:

* Literal
    package MyApp::Controller::My::Controller;
    sub bar : Path('foo/bar') { }
Literal CWPath actions will act relative to their current namespace. The above example matches only http://localhost:3000/my/controller/foo/bar. If you start your path with a forward slash, it will match from the root. Example:
    package MyApp::Controller::My::Controller;
    sub bar : Path('/foo/bar') { }
Matches only http://localhost:3000/foo/bar.
    package MyApp::Controller::My::Controller;
    sub bar : Path { }
By leaving the CWPath definition empty, it will match on the namespace root. The above code matches http://localhost:3000/my/controller.
* Regex
    sub bar : Regex('^item(\d+)/order(\d+)$') { }
Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/item23/order42. The '' around the regexp is optional, but perltidy likes it. :) Regex matches act globally, i.e. without reference to the namespace from which it is called, so that a CWbar method in the CWMyApp::Controller::Catalog::Order::Process namespace won't match any form of CWbar, CWCatalog, CWOrder, or CWProcess unless you explicitly put this in the regex. To achieve the above, you should consider using a CWLocalRegex action.
* LocalRegex
    sub bar : LocalRegex('^widget(\d+)$') { }
LocalRegex actions act locally. If you were to use CWbar in CWMyApp::Controller::Catalog, the above example would match urls like http://localhost:3000/catalog/widget23. If you omit the "CW^" from your regex, then it will match any depth from the controller and not immediately off of the controller name. The following example differs from the above code in that it will match http://localhost:3000/catalog/foo/widget23 as well.
    package MyApp::Controller::Catalog;
    sub bar : LocalRegex('widget(\d+)$') { }
For both LocalRegex and Regex actions, if you use capturing parentheses to extract values within the matching URL, those values are available in the CW$c->req->snippets array. In the above example, widget23 would capture 23 in the above example, and CW$c->req->snippets->[0] would be 23. If you want to pass arguments at the end of your URL, you must use regex action keys. See URL Path Handling below.
* Top-level
    package MyApp; 
    sub foo : Global { }
Matches http://localhost:3000/foo. The function name is mapped directly to the application base.
* Namespace-Prefixed
    package MyApp::Controller::My::Controller; 
    sub foo : Local { }
Matches http://localhost:3000/my/controller/foo. This action type indicates that the matching URL must be prefixed with a modified form of the component's class (package) name. This modified class name excludes the parts that have a pre-defined meaning in Catalyst (MyApp::Controller in the above example), replaces :: with /, and converts the name to lower case. See Components for a full explanation of the pre-defined meaning of Catalyst component class names.
* Private
    sub foo : Private { }
Matches no URL, and cannot be executed by requesting a URL that corresponds to the action key. Private actions can be executed only inside a Catalyst application, by calling the CWforward method:
See Flow Control for a full explanation of CWforward. Note that, as discussed there, when forwarding from another component, you must use the absolute path to the method, so that a private CWbar method in your CWMyApp::Controller::Catalog::Order::Process controller must, if called from elsewhere, be reached with CW$c->forward('/catalog/order/process/bar').

Note: After seeing these examples, you probably wonder what the point is of defining names for regex and path actions. Actually, every public action is also a private one, so you have one unified way of addressing components in your CWforwards.

Built-in Private Actions

In response to specific application states, Catalyst will automatically call these built-in private actions in your application class:

* default : Private
Called when no other action matches. Could be used, for example, for displaying a generic frontpage for the main app, or an error page for individual controllers. If CWdefault isn't acting how you would expect, look at using a Literal CWPath action (with an empty path string). The difference is that CWPath takes arguments relative from the namespace and CWdefault always takes arguments relative from the root, regardless of what controller it's in.
* index : Private
CWindex is much like CWdefault except that it takes no arguments and it is weighted slightly higher in the matching process. It is useful as a static entry point to a controller, e.g. to have a static welcome page. Note that it's also weighted higher than Path.
* begin : Private
Called at the beginning of a request, before any matching actions are called.
* end : Private
Called at the end of a request, after all matching actions are called.

Built-in actions in controllers/autochaining

    Package MyApp::Controller::Foo;
    sub begin : Private { }
    sub default : Private { }
    sub auto : Private { }

You can define built-in private actions within your controllers as well. The actions will override the ones in less-specific controllers, or your application class. In other words, for each of the three built-in private actions, only one will be run in any request cycle. Thus, if CWMyApp::Controller::Catalog::begin exists, it will be run in place of CWMyApp::begin if you're in the CWcatalog namespace, and CWMyApp::Controller::Catalog::Order::begin would override this in turn.

In addition to the normal built-in actions, you have a special action for making chains, CWauto. Such CWauto actions will be run after any CWbegin, but before your action is processed. Unlike the other built-ins, CWauto actions do not override each other; they will be called in turn, starting with the application class and going through to the most specific class. This is the reverse of the order in which the normal built-ins override each other.

Here are some examples of the order in which the various built-ins would be called:

  MyApp::Controller::Foo::default # in the absence of MyApp::Controller::Foo::Foo
  MyApp::Controller::Foo::Bar::default # for MyApp::Controller::Foo::Bar::foo

The CWauto action is also distinguished by the fact that you can break out of the processing chain by returning 0. If an CWauto action returns 0, any remaining actions will be skipped, except for CWend. So, for the request above, if the first auto returns false, the chain would look like this:


An example of why one might use this is an authentication action: you could set up a CWauto action to handle authentication in your application class (which will always be called first), and if authentication fails, returning 0 would skip any remaining methods for that URL.

Note: Looking at it another way, CWauto actions have to return a true value to continue processing! You can also CWdie in the autochain action; in that case, the request will go straight to the finalize stage, without processing further actions.

URL Path Handling

You can pass variable arguments as part of the URL path. In this case, you must use regex action keys with '^' and '$' anchors, and the arguments must be separated with forward slashes (/) in the URL. For example, suppose you want to handle CW/foo/$bar/$baz, where CW$bar and CW$baz may vary:

    sub foo : Regex('^foo$') { my ($self, $context, $bar, $baz) = @_; }

But what if you also defined actions for CW/foo/boo and CW/foo/boo/hoo?

    sub boo : Path('foo/boo') { .. }
    sub hoo : Path('foo/boo/hoo') { .. }

Catalyst matches actions in most specific to least specific order:

    /foo # might be /foo/bar/baz but won't be /foo/boo/hoo

So Catalyst would never mistakenly dispatch the first two URLs to the '^foo$' action.

Parameter Processing

Parameters passed in the URL query string are handled with methods in the Catalyst::Request class. The CWparam method is functionally equivalent to the CWparam method of and can be used in modules that require this.

    # http://localhost:3000/catalog/view/?category=hardware&page=3
    my $category = $c->req->param('category');
    my $current_page = $c->req->param('page') || 1;

    # multiple values for single parameter name
    my @values = $c->req->param('scrolling_list');

    # DFV requires a input hash
    my $results = Data::FormValidator->check($c->req->params, \%dfv_profile);

Flow Control

You control the application flow with the CWforward method, which accepts the key of an action to execute. This can be an action in the same or another Catalyst controller, or a Class name, optionally followed by a method name. After a CWforward, the control flow will return to the method from which the CWforward was issued.

A CWforward is similar to a method call. The main differences are that it wraps the call in an CWeval to allow exception handling; it automatically passes along the context object (CW$c or CW$context); and it allows profiling of each call (displayed in the log with debugging enabled).

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->stash->{message} = 'Hello World!';
        $c->forward('check_message'); # $c is automatically included

    sub check_message : Private {
        my ( $self, $c ) = @_;
        return unless $c->stash->{message};

    sub show_message : Private {
        my ( $self, $c ) = @_;
        $c->res->body( $c->stash->{message} );

A CWforward does not create a new request, so your request object (CW$c->req) will remain unchanged. This is a key difference between using CWforward and issuing a redirect.

You can pass new arguments to a CWforward by adding them in an anonymous array. In this case CW$c->req->args will be changed for the duration of the CWforward only; upon return, the original value of CW$c->req->args will be reset.

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->stash->{message} = 'Hello World!';
        # now $c->req->args is back to what it was before

    sub check_message : Private {
        my ( $self, $c ) = @_;
        my $first_argument = $c->req->args[0]; # now = 'test1'
        # do something...

As you can see from these examples, you can just use the method name as long as you are referring to methods in the same controller. If you want to forward to a method in another controller, or the main application, you will have to refer to the method by absolute path.

  $c->forward('/default'); # calls default in main application

Here are some examples of how to forward to classes and methods.

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->forward(qw/MyApp::Model::Hello say_hello/);

    sub bye : Global {
        my ( $self, $c ) = @_;
        $c->forward('MyApp::Model::Hello'); # no method: will try 'process'

    package MyApp::Model::Hello;

    sub say_hello {
        my ( $self, $c ) = @_;
        $c->res->body('Hello World!');

    sub process {
        my ( $self, $c ) = @_;
        $c->res->body('Goodbye World!');

Note that CWforward returns to the calling action and continues processing after the action finishes. If you want all further processing in the calling action to stop, use CWdetach instead, which will execute the CWdetached action and not return to the calling sub. In both cases, Catalyst will automatically try to call process() if you omit the method.


Catalyst has an uncommonly flexible component system. You can define as many Models, Views, and Controllers as you like.

All components must inherit from Catalyst::Base, which provides a simple class structure and some common class methods like CWconfig and CWnew (constructor).

    package MyApp::Controller::Catalog;

    use strict;
    use base 'Catalyst::Base';

    __PACKAGE__->config( foo => 'bar' );


You don't have to CWuse or otherwise register Models, Views, and Controllers. Catalyst automatically discovers and instantiates them when you call CWsetup in the main application. All you need to do is put them in directories named for each Component type. Notice that you can use some very terse aliases for each one.

* MyApp/Model/
* MyApp/M/
* MyApp/View/
* MyApp/V/
* MyApp/Controller/
* MyApp/C/


To show how to define views, we'll use an already-existing base class for the Template Toolkit, Catalyst::View::TT. All we need to do is inherit from this class:

    package MyApp::View::TT;

    use strict;
    use base 'Catalyst::View::TT';


(You can also generate this automatically by using the helper script:

    script/ view TT TT

where the first CWTT tells the script that the name of the view should be CWTT, and the second that it should be a Template Toolkit view.)

This gives us a process() method and we can now just do CW$c->forward('MyApp::View::TT') to render our templates. The base class makes process() implicit, so we don't have to say CW$c->forward(qw/MyApp::View::TT process/).

    sub hello : Global {
        my ( $self, $c ) = @_;
        $c->stash->{template} = '';

    sub end : Private {
        my ( $self, $c ) = @_;

You normally render templates at the end of a request, so it's a perfect use for the global CWend action.

Also, be sure to put the template under the directory specified in CW$c->config->{root}, or you'll be forced to look at our eyecandy debug screen. ;)


To show how to define models, again we'll use an already-existing base class, this time for Class::DBI: Catalyst::Model::CDBI.

But first, we need a database.

    -- myapp.sql
    CREATE TABLE foo (
        data TEXT

    CREATE TABLE bar (
        foo INTEGER REFERENCES foo,
        data TEXT

    INSERT INTO foo (data) VALUES ('TEST!');

    % sqlite /tmp/myapp.db < myapp.sql

Now we can create a CDBI component for this database.

    package MyApp::Model::CDBI;

    use strict;
    use base 'Catalyst::Model::CDBI';

        dsn           => 'dbi:SQLite:/tmp/myapp.db',
        relationships => 1


Catalyst automatically loads table layouts and relationships. Use the stash to pass data to your templates.

    package MyApp;

    use strict;
    use Catalyst '-Debug';

        name => 'My Application',
        root => '/home/joeuser/myapp/root'


    sub end : Private {
        my ( $self, $c ) = @_;
        $c->stash->{template} ||= '';

    sub view : Global {
        my ( $self, $c, $id ) = @_;
        $c->stash->{item} = MyApp::Model::CDBI::Foo->retrieve($id);


    # Then, in a TT template:
    The id is [% %]

Models do not have to be part of your Catalyst application; you can always call an outside module that serves as your Model:

    # in a Controller
    sub list : Local {
      my ( $self, $c ) = @_;
      $c->stash->{template} = '';
      use Some::Outside::CDBI::Module;
      my @records = Some::Outside::CDBI::Module->retrieve_all;
      $c->stash->{records} = \@records;

But by using a Model that is part of your Catalyst application, you gain several things: you don't have to CWuse each component, Catalyst will find and load it automatically at compile-time; you can CWforward to the module, which can only be done to Catalyst components; and only Catalyst components can be fetched with CW$c->model('SomeModel').

Happily, since many people have existing Model classes that they would like to use with Catalyst (or, conversely, they want to write Catalyst models that can be used outside of Catalyst, e.g. in a cron job), it's trivial to write a simple component in Catalyst that slurps in an outside Model:

    package MyApp::Model::Catalog;
    use base qw/Catalyst::Base Some::Other::CDBI::Module::Catalog/;

and that's it! Now CWSome::Other::CDBI::Module::Catalog is part of your Cat app as CWMyApp::Model::Catalog.


Multiple controllers are a good way to separate logical domains of your application.

    package MyApp::Controller::Login;

    sub sign-in : Local { }
    sub new-password : Local { }
    sub sign-out : Local { }

    package MyApp::Controller::Catalog;

    sub view : Local { }
    sub list : Local { }

    package MyApp::Controller::Cart;

    sub add : Local { }
    sub update : Local { }
    sub order : Local { }


Catalyst has a built-in http server for testing! (Later, you can easily use a more powerful server, e.g. Apache/mod_perl, in a production environment.)

Start your application on the command line...


...then visit http://localhost:3000/ in a browser to view the output.

You can also do it all from the command line:

    script/ http://localhost/

Have fun!



    Join #catalyst on



Sebastian Riedel, David Naughton, Marcus Ramberg, Jesse Sheidlower, Danijel Milicevic,


This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself.