diff --git a/examples/messaging/messaging.cpp b/examples/messaging/messaging.cpp
index b4033cb..4d280b5 100644
--- a/examples/messaging/messaging.cpp
+++ b/examples/messaging/messaging.cpp
@@ -1,169 +1,140 @@
 /*******************************************************************************
  *
  * File:     messaging.cpp
  *
  * Contents: An example showcasing features related to Messages.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/config/version.h"
 #include "rosa/core/MessageHandler.hpp"
 #include "rosa/support/log.h"
 #include "rosa/support/terminal_colors.h"
 #include <iostream>
 
 using namespace rosa;
 using namespace rosa::terminal;
 
-// A simple implementation of the Message interface with two hardcoded types.
-class MyMessage : public Message {
-  const uint8_t U8;   // First value
-  const uint16_t U16; // Second value
-public:
-  MyMessage(const uint8_t U8, const uint16_t U16)
-      : Message(U8, U16), U8(U8), U16(U16) {}
-
-  const void *getPointerTo(const size_t Pos) const noexcept override {
-    switch (Pos) {
-    default:
-      ROSA_CRITICAL("wrong position");
-    case 0:
-      return &U8;
-    case 1:
-      return &U16;
-    }
-  }
-};
-
-// Another implementation of the Message interface with an AtomValue.
-class MyAtomMessage : public Message {
-  const AtomValue A; // First value
-public:
-  template <AtomValue V>
-  MyAtomMessage(AtomConstant<V> C) : Message(C), A(V) {}
-
-  const void *getPointerTo(const size_t Pos) const noexcept override {
-    switch (Pos) {
-    default:
-      ROSA_CRITICAL("wrong position");
-    case 0:
-      return &A;
-    }
-  }
-};
-
 int main(void) {
   LOG_INFO_STREAM << library_string() << " -- " << Color::Red
                   << "messaging" << Color::Default << std::endl;
 
   auto &Log = LOG_INFO_STREAM << std::endl;
 
   // Message interface.
-  MyMessage Msg(1, 2);
-  Log << "Checking on 'MyMessage(1, 2)' that is of 'Message with "
-         "TypeList<<uint8_t, uint16_t>>':"
+  auto PMsg = Message::create<uint8_t, uint16_t>(1, 2);
+  auto &Msg = *PMsg;
+  Log << "Checking on a 'Message with TypeList<<uint8_t, uint16_t>>':"
       << std::endl
       << "  Size: " << Msg.Size << std::endl
       << "  Pos 0 is uint8_t: " << Msg.isTypeAt<uint8_t>(0) << std::endl
       << "  Pos 1 is uint16_t: " << Msg.isTypeAt<uint16_t>(1) << std::endl
       << "  Pos 2 is uint32_t: " << Msg.isTypeAt<uint32_t>(1) << std::endl
       << "  Value at pos 0: " << PRINTABLE(uint8_t)(Msg.getValueAt<uint8_t>(0))
       << std::endl
       << "  Value at pos 1: " << Msg.getValueAt<uint16_t>(1) << std::endl
       << std::endl;
 
   // MessageMatcher.
   using MyMatcher = MsgMatcher<uint8_t, uint16_t>;
   Log << "Matching against 'TypeList<uint8_t, uint16_t>':" << std::endl
       << "  matching: " << MyMatcher::doesStronglyMatch(Msg) << std::endl;
   auto Vs = MyMatcher::extractedValues(Msg);
   Log << "  value: '(" << PRINTABLE(uint8_t)(std::get<0>(Vs)) << ", "
       << std::get<1>(Vs) << ")'" << std::endl
       << std::endl;
 
   using MyWrongMatcher = MsgMatcher<uint8_t, uint8_t>;
   Log << "Matching against 'TypeList<uint8_t, uint8_t>':" << std::endl
       << "  matching: " << MyWrongMatcher::doesStronglyMatch(Msg) << std::endl
       << std::endl;
 
   using MyAtom = AtomConstant<atom("atom")>;
   const MyAtom &A = MyAtom::Value;
   using MyNAtom = AtomConstant<atom("noatom")>;
-  MyAtomMessage AMsg(A);
-  Log << "Checking on 'MyAtomMessage(AtomConstant<atom(\"atom\")>::Value)' "
-         "that is of 'Message with TypeList<AtomConstant<atom(\"atom\")>>':"
+  auto PAMsg = Message::create(A);
+  auto &AMsg = *PAMsg;
+  Log << "Checking on a 'Message with TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  Size: " << AMsg.Size << std::endl
       << "  Pos 0 is 'AtomValue': " << AMsg.isTypeAt<AtomValue>(0) << std::endl
       << "  Pos 0 is 'AtomConstant<atom(\"noatom\")>': "
       << AMsg.isTypeAt<MyNAtom>(0) << std::endl
       << std::endl;
 
   using MyAtomMatcher = MsgMatcher<MyAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  matching: " << MyAtomMatcher::doesStronglyMatch(AMsg) << std::endl
       << "  value: '("
       << to_string(std::get<0>(MyAtomMatcher::extractedValues(AMsg))) << ")'"
       << std::endl
       << std::endl;
 
   using MyWrongAtomMatcher = MsgMatcher<MyNAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"noatom\")>>':"
       << std::endl
       << "  matching: " << MyWrongAtomMatcher::doesStronglyMatch(AMsg)
       << std::endl
       << std::endl;
 
   // Invoker.
   auto IP = Invoker::wrap(Invoker::F<MyAtom>([&Log](MyAtom) noexcept->void {
-    Log << "** Handling 'Message with TypeList<MyAtom>'." << std::endl;
+    Log << "** Handling 'Message with TypeList<AtomConstant<atom(\"atom\")>>'."
+        << std::endl;
   }));
   auto &I = *IP; // Get a reference from the pointer.
-  Log << "Invoking a function of signature 'void(MyAtom) noexcept':"
+  Log << "Invoking a function of signature 'void(AtomConstant<atom(\"atom\")>) "
+         "noexcept':"
       << std::endl
       << "  with 'Message with TypeList<uint8_t, uint16_t>'" << std::endl
       << "    does Message match Invoker: " << I.match(Msg) << std::endl
       << "    invoking..." << std::endl;
   I(Msg);
-  Log << "  with 'Message with TypeList<MyAtom>'..." << std::endl
+  Log << "  with 'Message with TypeList<AtomConstant<atom(\"atom\")>>'..."
+      << std::endl
       << "    does Message match Invoker: " << I.match(AMsg) << std::endl
       << "    invoking..." << std::endl;
   I(AMsg);
   Log << std::endl;
 
   // MessageHandler.
   MessageHandler Handler{
-      Invoker::F<uint8_t, uint16_t>([&](uint8_t, uint16_t) {
-        LOG_TRACE("** Handling 'Message with TypeList<uint8_t, uint16_t>'");
+      Invoker::F<uint8_t, uint16_t>([&Log](uint8_t, uint16_t) {
+        Log << "** Handling 'Message with TypeList<uint8_t, uint16_t>'"
+            << std::endl;
       }),
-      Invoker::F<MyAtom>([&](MyAtom) {
-        LOG_TRACE("** Handling 'Message with TypeList<MyAtom>'");
+      Invoker::F<MyAtom>([&Log](MyAtom) {
+        Log << "** Handling 'Message with "
+               "TypeList<AtomConstant<atom(\"atom\")>>'" << std::endl;
       })};
-  MyAtomMessage ANMsg(MyNAtom::Value);
+  auto PANMsg = Message::create(MyNAtom::Value);
+  auto &ANMsg = *PANMsg;
   Log << "Handling Messages with 'MessageHandler "
-         "{ Invoker::F<uint8_t, uint16_t>, Invoker::F<MyAtom> }':"
+         "{ Invoker::F<uint8_t, uint16_t>, "
+         "Invoker::F<AtomConstant<atom(\"atom\")>> }':"
       << std::endl
       << "  'Message with TypeList<uint8_t, uint16_t>'" << std::endl
       << "    can handle: " << Handler.canHandle(Msg) << std::endl
       << "    handling..." << std::endl;
   Handler(Msg);
-  Log << "  'Message with TypeList<MyAtom>'" << std::endl
+  Log << "  'Message with TypeList<AtomConstant<atom(\"atom\")>>'" << std::endl
       << "    can handle: " << Handler.canHandle(AMsg) << std::endl
       << "    handling..." << std::endl;
   Handler(AMsg);
-  Log << "  'Message with TypeList<MyNAtom>'" << std::endl
+  Log << "  'Message with TypeList<AtomConstant<atom(\"noatom\")>>'"
+      << std::endl
       << "    can handle: " << Handler.canHandle(ANMsg) << std::endl
       << "    handling..." << std::endl;
   Handler(ANMsg);
   Log << std::endl;
 
   Log << "Terminating, destroying automatic variables." << std::endl;
 
   return 0;
 }
 
diff --git a/include/rosa/core/Message.hpp b/include/rosa/core/Message.hpp
index 74d124a..d02586c 100644
--- a/include/rosa/core/Message.hpp
+++ b/include/rosa/core/Message.hpp
@@ -1,92 +1,306 @@
 /*******************************************************************************
  *
  * File:     Message.hpp
  *
  * Contents: Declaration of Message base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_MESSAGE_HPP
 #define ROSA_CORE_MESSAGE_HPP
 
 #include "rosa/support/log.h"
 #include "rosa/support/type_token.hpp"
+#include <memory>
+#include <vector>
 
 namespace rosa {
 
 // Message interface. The interface provides means to check the type of the
 // stored values, but actual data is to be managed by derived implementations.
 // Messages are immutable data objects, obtaining their data upon creation and
 // providing only constant references for the stored values.
 // NOTE: Any reference obtained from a Message instance remains valid only as
 // long as the owning Message object is not destroyed.
 class Message {
 protected:
   // Ctor.
   // NOTE: No implementation for empty list.
-  template <typename Type, typename... Ts> Message(Type, Ts...) noexcept;
+  template <typename Type, typename... Ts>
+  Message(const Type &, const Ts &...) noexcept;
 
   // No copy and move.
   Message(const Message &) = delete;
   Message(Message &&) = delete;
   Message &operator=(const Message &) = delete;
   Message &operator=(Message &&) = delete;
 
 public:
+  // Type alias for a smart pointer for Message.
+  using message_t = std::unique_ptr<Message>;
+
+  // Factory function to locally create a Message instance from constant
+  // references.
+  template <typename Type, typename... Types>
+  static message_t create(const Type &T, const Types &... Ts) noexcept;
+
+  // Factory function to locally create a Message instance from movable
+  // references.
+  template <typename Type, typename... Types>
+  static message_t create(Type &&T, Types &&... Ts) noexcept;
+
   // A valid, non-empty token representing the types of the values stored in
   // the Message.
   const Token T;
 
   // The number of types encoded in T, that is the number of values stored in
   // Message.
   const size_t Size;
 
   // Virtual dtor.
   virtual ~Message(void);
 
   // Tells if the value in position Pos is of type Type.
   // NOTE: Token encodes atoms as AtomValue and not directly AtomConstants.
   // PRE: Pos < Size
   template <typename Type> bool isTypeAt(const size_t Pos) const noexcept;
 
   // Gives a constant reference of the value of type Type in position Pos.
   // PRE: Pos < Size && isTypeAt(Pos)
   template <typename Type>
   const Type &getValueAt(const size_t Pos) const noexcept;
 
 protected:
   // Provides an untyped pointer for the value in position Pos.
   // PRE: Pos < Size
   virtual const void *getPointerTo(const size_t Pos) const noexcept = 0;
 };
 
+// Nested namespace with an implementation for Message, consider it private.
+namespace {
+
+// Template class for an implementation of Message, definition below.
+template <typename... Types> class LocalMessage;
+
+// Initializes Arena with values from const references of Types.
+// NOTE: Arena needs to be a valid pointer to a memory area big enough for
+// values of Types.
+template <typename... Types>
+inline void createMessageElements(void *const Arena,
+                                  const Types &... Ts) noexcept;
+
+// NOTE: This terminal case is used for both constant references and movable
+// references.
+template <size_t Pos>
+inline void createMessageElement(void *const,
+                                 const std::vector<size_t> &Offsets) {
+  ASSERT(Pos == Offsets.size());
+}
+
+template <size_t Pos, AtomValue V, typename... Types>
+inline void
+createMessageElement(void *const Arena, const std::vector<size_t> &Offsets,
+                     const AtomConstant<V> &, const Types &... Ts) noexcept {
+  ASSERT(Arena != nullptr && Pos < Offsets.size());
+  *static_cast<AtomValue *>(
+      static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
+  createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
+}
+
+template <size_t Pos, typename Type, typename... Types>
+inline void createMessageElement(void *const Arena,
+                                 const std::vector<size_t> &Offsets,
+                                 const Type &T, const Types &... Ts) noexcept {
+  ASSERT(Arena != nullptr && Pos < Offsets.size());
+  new (static_cast<Type *>(static_cast<void *>(static_cast<uint8_t *>(Arena) +
+                                               Offsets[Pos]))) Type(T);
+  createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
+}
+
+template <typename Type, typename... Types>
+inline void createMessageElements(void *const Arena, const Type &T,
+                                  const Types &... Ts) noexcept {
+  ASSERT(Arena != nullptr);
+  createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets, T,
+                          Ts...);
+}
+
+// Initializes Arena with values from movable references of Types.
+// NOTE: Arena needs to be a valid pointer to a memory area big enough for
+// values of Types.
+template <typename... Types>
+inline void createMessageElements(void *const Arena, Types &&... Ts) noexcept;
+
+template <size_t Pos, AtomValue V, typename... Types>
+inline void createMessageElement(void *const Arena,
+                                 const std::vector<size_t> &Offsets,
+                                 AtomConstant<V> &&, Types &&... Ts) noexcept {
+  ASSERT(Arena != nullptr && Pos < Offsets.size());
+  *static_cast<AtomValue *>(
+      static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
+  createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
+}
+
+template <size_t Pos, typename Type, typename... Types>
+inline void createMessageElement(void *const Arena,
+                                 const std::vector<size_t> &Offsets, Type &&T,
+                                 Types &&... Ts) noexcept {
+  ASSERT(Arena != nullptr && Pos < Offsets.size());
+  new (static_cast<Type *>(static_cast<void *>(
+      static_cast<uint8_t *>(Arena) + Offsets[Pos]))) Type(std::move(T));
+  createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
+}
+
+template <typename Type, typename... Types>
+inline void createMessageElements(void *const Arena, Type &&T,
+                                  Types &&... Ts) noexcept {
+  ASSERT(Arena != nullptr);
+  createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets,
+                          std::move(T), std::move(Ts)...);
+}
+
+// Destroyes values of Types stored in Arena.
+// NOTE: Arena needs to be a valid pointer to a memory area where values of
+// Types are stored.
+template <typename Type, typename... Types>
+inline void destroyMessageElements(void *const Arena) noexcept;
+
+template <size_t Pos>
+inline void destroyMessageElement(void *const,
+                                  const std::vector<size_t> &Offsets) noexcept {
+  ASSERT(Pos == Offsets.size());
+}
+
+template <size_t Pos, typename Type, typename... Types>
+inline void destroyMessageElement(void *const Arena,
+                                  const std::vector<size_t> &Offsets) noexcept {
+  ASSERT(Arena != nullptr && Pos < Offsets.size());
+  static_cast<Type *>(
+      static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos]))
+      ->~Type();
+  destroyMessageElement<Pos + 1, Types...>(Arena, Offsets);
+}
+
+template <typename Type, typename... Types>
+inline void destroyMessageElements(void *const Arena) noexcept {
+  destroyMessageElement<0, Type, Types...>(
+      Arena, LocalMessage<Type, Types...>::Offsets);
+}
+
+// Implementation of the template LocalMessage. Provides facilities for storing
+// values as a Message.
+template <typename Type, typename... Types>
+class LocalMessage<Type, Types...> : public Message {
+public:
+  // Type Token for the stored values.
+  // NOTE: Only for compile-time checks, static member is not defined.
+  static constexpr Token ST =
+      TypeToken<typename std::decay<Type>::type,
+                typename std::decay<Types>::type...>::Value;
+
+  // Offsets required to access values in Arena.
+  static const std::vector<size_t> Offsets;
+
+private:
+  // A BLOB storing all the values one after the other.
+  void *const Arena;
+
+  // Generates offset for accessing values in Arena.
+  static std::vector<size_t> getOffsets(void) noexcept {
+    Token T = ST;                            // Need a mutable copy.
+    size_t I = 0;                            // Start indexing from position 0.
+    std::vector<size_t> O(lengthOfToken(T)); // Allocate vector of proper size.
+    O[0] = 0;                                // First offset is always 0.
+    while (!emptyToken(T)) {
+      ASSERT(I < O.size());
+      // Calculate next offset based on the previous one.
+      O[I + 1] = O[I] + sizeOfHeadOfToken(T);
+      dropHeadOfToken(T), ++I;
+    }
+    ASSERT(I == O.size());
+    return O;
+  }
+
+public:
+  // Ctor for constant references.
+  LocalMessage(const Type &T, const Types &... Ts) noexcept
+      : Message(T, Ts...),
+        Arena(::operator new(sizeOfValuesOfToken(ST))) {
+    ASSERT(this->T == ST && Size == Offsets.size() &&
+           Arena != nullptr); // Sanity check.
+    createMessageElements(Arena, T, Ts...);
+  }
+
+  // Ctor for movable referecens.
+  LocalMessage(Type &&T, Types &&... Ts) noexcept
+      : Message(T, Ts...),
+        Arena(::operator new(sizeOfValuesOfToken(ST))) {
+    ASSERT(this->T == ST && Size == Offsets.size() &&
+           Arena != nullptr); // Sanity check.
+    createMessageElements(Arena, std::move(T), std::move(Ts)...);
+  }
+
+  // Dtor.
+  ~LocalMessage(void) {
+    destroyMessageElements<Type, Types...>(Arena);
+    ::operator delete(Arena);
+  }
+
+  // Provides an untyped pointer for the constant value at Pos.
+  const void *getPointerTo(const size_t Pos) const noexcept override {
+    ASSERT(Pos < Offsets.size());
+    return static_cast<uint8_t *>(Arena) + Offsets[Pos];
+  }
+};
+
+// Implementation of the static member field Offsets.
+template <typename Type, typename... Types>
+const std::vector<size_t> LocalMessage<Type, Types...>::Offsets =
+    LocalMessage<Type, Types...>::getOffsets();
+
+} // End namespace
+
 template <typename Type, typename... Ts>
-Message::Message(Type, Ts...) noexcept : T(TypeToken<Type, Ts...>::Value),
-                                         Size(lengthOfToken(T)) {
+Message::Message(const Type &, const Ts &...) noexcept
+    : T(TypeToken<typename std::decay<Type>::type,
+                  typename std::decay<Ts>::type...>::Value),
+      Size(lengthOfToken(T)) {
   ASSERT(validToken(T) &&
          lengthOfToken(T) == (1 + sizeof...(Ts))); // Sanity check.
   LOG_TRACE("Creating Message with Token(" + to_string(T) + ")");
 }
 
+template <typename Type, typename... Types>
+Message::message_t Message::create(const Type &T,
+                                   const Types &... Ts) noexcept {
+  return message_t(new LocalMessage<Type, Types...>(T, Ts...));
+}
+
+template <typename Type, typename... Types>
+Message::message_t Message::create(Type &&T, Types &&... Ts) noexcept {
+  return message_t(
+      new LocalMessage<Type, Types...>(std::move(T), std::move(Ts)...));
+}
+
 template <typename Type>
 bool Message::isTypeAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size);
   Token T_ = T; // NOLINT
   dropNOfToken(T_, Pos);
   return isHeadOfTokenTheSameType<Type>(T_);
 }
 
 template <typename Type>
 const Type &Message::getValueAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size && isTypeAt<Type>(Pos));
   return *static_cast<const Type *>(getPointerTo(Pos));
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_MESSAGE_HPP