Aurita is a resource-based application framework that simplifies realization of rich internet applications. Application are composed of plug-ins and can be everything from a todo list up to a distributed community portal. Some screenshots are here:
JavaScript Ruby Shell
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


Welcome to Aurita

This is the API documentation for Aurita's core implementation.

In total, there are the following API documentations:


Aurita's core (this API):


Aurita's core application logic API:


Object-oriented GUI API:


Aurita's vendor plugins:


Aurita's ORM:


All APIs in one (big!):

Who is developing Aurita?

We are a small software company in Munich, Germany. We develop web applications of any flavor since 2000. We develop custom-fitted applications for mostly medium-sized companies (200-500 employees or so). As we are small, we need tools that support fast and agile development cycles. That's why i (fuchsto) started Aurita about three years ago (There is a whole bunch of reasons why we didn't just go for Rails, especially back then, when Rails was 0.9). Our products are open source, and so is our framework.

What does Aurita do, in general?

A typical Aurita application consists of the following layers:

  1. Web server (usually nginx)

  2. Proxies (thin, mongrel, webrick, …)

  3. Middleware (rack or custom handler)

  4. Aurita's dispatcher applications

  5. The app's Model / View / Controller / Modules, usually some of Aurita's plug-ins combined with app-specific code.

Aurita itself implements layers 2 to 4. Layer 5 (the actual application) usually consists of plug-in code. For a simple plug-in example, see the aurita-mailing-plugin here:

Middleware tasks are implemented by a Aurita-specific Rack middleware (Aurita::Handler::Aurita_Application), so it is compatible with web servers like Thin, Mongrel, Lighttpd, Apache and many more. There are specific adapters for Thin (Aurita::Thin_Daemon) and Mongrel (Aurita::Mongrel_Daemon). Thin is recommended and used by default. Of course, Aurita + Thin can be used behind HAProxy and Unicorn, which is recommended for enterprisey production environments.


The most interesting part. Controllers implement pure business logic and client / server interaction. Controllers use models to retreive and modify data, and views to display them.


  • Aurita::Base_Controller

  • Aurita::Base_Controller_Methods


Lore ORM is used for defining and working with models and DB abstraction. Aurita extends Lore::Model by several behaviours, like Categorized_Behaviour and Taggable_Behaviour.

See Aurita::Model


There are two ways how user interfaces can be generated: Templates and GUI elements.

Templates are the a well-known standard: Write an interface skeleton with close to no intelligence, fill in values, and print it. Templates are ERB files residing in folders named “views” (in Aurita itself, in plugins, or in the project).

Aurita also offers GUI elements, which are real Ruby objects, This concept is comparable to e.g. Qt: Define a class derived from Aurita::GUI::Element or Aurita::GUI::Widget, create instances of it, and render them at the very end. This way, a GUI element class can be derived from an existing one. This is especially needed for rich internet application toolkits.

The advantage of GUI objects over templates is flexibility and reuse of interface logic - ever tried to reuse an HTML template but with slight changes? This is where they come to play.

In general, both are necessary. Use templates for interface parts that do not offer complex functionality but are quickly written in HTML. However, you should consider using a GUI object for a table that is sortable by columns, for instance.

A controller that responds with an interface may either render a template or return an Aurita::GUI::Element instance.

See documentation on Aurita::GUI

  • Aurita::View_Helpers

  • Aurita::GUI::Element

  • Aurita::GUI::HTML

  • Aurita::GUI::Widget


Aurita is a plugin-based application framework. That is to say, it offers basic application logic that is supposed to be useful in all applications based on it, but without plugins, it would just be a blank page.

Aurita::Main - which includes core models / views / controllers - is treated as a plugin, too, but it is loaded automatically in every Aurita project.

Aurita::Main also includes lots of GUI modules. Context menus, tables and much more can be used easily for every business object right away, for instance.

By using Aurita::Main and adding existing plugins, you can write your own application without having to reinvent tagging, user management, versioning, digital asset management, form generation … for every project.

If your project needs a wiki, add the Wiki plugin. If you need todo lists, add the Todo plugin, and so on. Plugins do not have to be stand-alone: The Todo plugin can hook into the Wiki plugin so todo lists can be added to an article. Of course it's possible to just use parts of a plugin's functions.

See documentation on Aurita::Plugins

  • Aurita::Plugin::Manifest

  • Aurita::Plugin_Register


Aurita has been developed by Tobias Fuchs and released under the liberal MIT licence (See LICENSE file in your distribution).