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 quickly get a simple application up and running.

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 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...

  • 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, Johson and Vlissides, a.k.a. the Gang of Four (GoF). Or just search the web. Many, many web application frameworks follow MVC, including all those listed above.


Catalyst is much more flexible than many other frameworks.

  • 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 is very flexible about these Components. 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, plus retrieve some data via LDAP? No problem. Want to present data from the same Model using Template Toolkit and PDF::Template? Easy.

  • Re-Useable 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 via regular expressions! Unlike some 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:

        MyApp->action( 'hello' => sub {
            my ( $self, $context ) = @_;
            $context->response->output('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 in 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 use 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. You can even get an instant web database front end with Catalyst::Model::CDBI::CRUD.

  • Builtin Test Framework

    Catalyst comes with a builtin, 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.


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


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


    $ My::App
    $ cd My-App
    $ script/ controller My::Controller


    $ 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',
        root => '/home/joeuser/myapp/root',

        # You can put whatever you want in here:
        # my_param_name => $my_param_value,

    MyApp->action( '!default' => sub {
        my ( $self, $context ) = @_;
        $context->response->output('Catalyst rockz!');


For most applications, Catalyst requires you to define only two config parameters:

  • name

    Name of your application.

  • root

    Path to additional files like templates, images or other static data.

However, you can define as many parameters as you want for plugins or whatever you need. You can access them anywhere in your application via $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.

As illustrated earlier 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 $context for clarity, but most Catalyst developers just call it $c:

    MyApp->action( 'hello' => sub {
        my ( $self, $c ) = @_;
        $c->res->output('Hello World!');

The Context contains several important objects:

  • Catalyst::Request

        $c->req # alias

    The request 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->output('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:


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

        '!show-message' => sub {
            my ( $self, $c ) = @_;
            $c->res->output( $c->stash->{message} );



To define a Catalyst action, register it into your application with the action method. action accepts a key-value pair, where the key represents one or more URLs or application states and the value is a code reference, the action to execute in reponse to the URL(s) or application state(s).

Catalyst supports several ways to define Actions:

  • Literal

        MyApp->action( 'foo/bar' => sub { } );

    Matches only http://localhost:3000/foo/bar.

  • Regex

        MyApp->action( '/^foo(\d+)/bar(\d+)$/' => sub { } );

    Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/foo23/bar42. The pattern must be enclosed with forward slashes, i.e. '/$pattern/'.

    If you use capturing parantheses to extract values within the matching URL (23, 42 in the above example), those values are available in the $c->req->snippets array. If you want to pass arguments at the end of your URL, you must use regex action keys. See "URL Argument Handling" below.

  • Namespace-Prefixed

        package MyApp::Controller::My::Controller; 
        MyApp->action( '?foo' => sub { } );

    Matches http://localhost:3000/my_controller/foo. The action key must be prefixed with '?'.

    Prefixing the action key with '?' 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

        MyApp->action( '!foo' => sub { } );

    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 forward method:


    See "Flow Control" for a full explanation of forward.

Builtin Private Actions

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

  • !default

    Called when no other action matches.

  • !begin

    Called at the beginning of a request, before any matching actions are called.

  • !end

Called at the end of a request, after all matching actions are called.

Namespace-Prefixed Private Actions

    MyApp->action( '!?foo' => sub { } );
    MyApp->action( '!?default' => sub { } );

The leading '!?' indicates that these are namespace-prefixed private actions. These override any application-wide private actions with the same names, and can be called only from within the namespace in which they are defined. Any private action can be namespace-prefixed, including the builtins. One use for this might be to give a Controller its own !?default, !?begin and !?end.

URL Argument Handling

If you want to pass variable arguments at the end of a URL, you must use regex actions keys with '^' and '$' anchors, and the arguments must be separated with forward slashes (/) in the URL. For example, suppose you want to handle /foo/$bar/$baz, where $bar and $baz may vary:

    MyApp->action( '/^foo$/' => sub { my ($self, $context, $bar, $baz) = @_; } ); 

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

    MyApp->action( '/foo/boo' => sub { .. } );
    MyApp->action( '/foo/boo/hoo' => sub { .. } );

Catalyst matches actions in most specific to least specific order:

    /foo # might be /foo/bar/baz

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

Flow Control

Control the application flow with the forward method, which accepts the key of an action to execute.


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

        '!check-message' => sub {
            my ( $self, $c ) = @_;
            return unless $c->stash->{message};

        '!show-message' => sub {
            my ( $self, $c ) = @_;
            $c->res->output( $c->stash->{message} );


You can also forward to classes and methods.


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

        'bye' => sub {
            my ( $self, $c ) = @_;


    package MyApp::M::Hello;

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

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

Note that forward returns after processing. Catalyst will automatically try to call process() if you omit the method.


Again, 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 config and new (constructor).

    package MyApp::Controller::MyController;

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

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


You don't have to use or otherwise register Models, Views and Controllers. Catalyst automatically discovers and instantiates them, at startup. 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::V::TT;

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


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


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

        '!end' => sub {
            my ( $self, $c ) = @_;


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

Also, be sure to put the template under the directory specified in $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::M::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'


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

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



    The id is [% %]


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

    package MyApp::C::Login;

        '?sign-in' => sub { },
        '?new-password' => sub { },
        '?sign-out' => sub { },

    package MyApp::C::Catalog;

        '?view' => sub { },
        '?list' => sub { },

    package MyApp::C::Cart;

        '?add' => sub { },
        '?update' => sub { },
        '?order' => sub { },


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, and David Naughton,


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

2 POD Errors

The following errors were encountered while parsing the POD:

Around line 74:

'=item' outside of any '=over'

Around line 94:

You forgot a '=back' before '=head2'