Ruote active development ceased.

Active development on ruote ceased.

See scaling down ruote

Do not involve ruote in your new project.

I still offer support on the ruote mailing list for existing projects, though.

Ruote is a workflow engine written in Ruby. Ruote is not a state machine library.


Last version is 2.3.0, it was released 2012/09/04.


Here is a re-hash of the quickstart exposing the core concepts in ruote.

Ruote as a workflow engine comes as an “onion”. There’s a storage at the core, taking care of all the persistence. A worker where all the orchestration work happens surrounds the core. The dashboard has all the levers to launch, pause, cancel process instances.

            require 'rufus-json/automatic'
            require 'ruote'
            require 'ruote/storage/fs_storage'
            ruote =

The orchestration work (making the work flow) happens in the worker(s), the orchestrated work (where the added value is) happens in participants.

            class Scout < Ruote::Participant
              def on_workitem
                result =
                  [ workitem.participant_name, (20 * rand + 1).to_i ]
                (workitem.fields['spotted'] ||= []) << result
                p result
                reply # work done, let flow resume
            class Leader < Ruote::Participant
              def on_workitem
                workitem.fields['total'] =
                  workitem.fields['spotted'].inject(0) { |t, f| t + f[1] }
                puts "bird:    " + workitem.fields['bird']
                puts "spotted: " + workitem.fields['spotted'].inspect
                puts "total:   " + workitem.fields['total'].inspect
                reply # work done, let flow resume

Participant names are mapped to participant implementations via a register call.

            ruote.register /^scout_/, Scout
            ruote.register /^leader_/, Leader

A process definition can be expressed in radial (a mini-language specific to ruote), in Ruby, in XML or directly as a (JSON) abstract tree.

Here is a radial example:

            pdef = %q{
                concurrence merge_type: concat

This process definition fans work to three scout participants and then hands the resulting work (item) to the team leader.

Here is the same flow expressed in Ruby:

            pdef = Ruote.define do
              concurrence :merge_type => :concat do

Multiple process instances can be launched at the same time. Multiple instances of different processes with different initial workitem fields can be launched in the same system and run in parallel, much like different processes on top of an OS.

            wfid = ruote.launch(
              'bird' => %w[ thrush cardinal dodo ].shuffle.first)


Ruote is available under the MIT open source license.

Ruote used to be named ‘openwfe-ruby’ then ‘openwferu’. The name is now ‘ruote’ (pronounce it ‘ru-o-te’ or ‘route’, as you wish).

For more, head to the documentation or to the quickstart or have a look at a few slides.


The mailing list is still the ‘openwferu’ one at

The channel is #ruote, feel free to stop by for a chat and a coffee. The channel archives are available at

See source for a list of the ruote related projects on github.

Here is a non-exhaustive list of organizations using ruote.