Index: src/Actions/Action.hpp
===================================================================
--- src/Actions/Action.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Actions/Action.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -14,4 +14,5 @@
 #endif
 
+#include <algorithm>
 #include <iosfwd>
 #include <string>
@@ -24,4 +25,15 @@
  */
 #define NOPARAM_DEFAULT BOOST_PP_NIL
+
+namespace MoleCuilder {
+  //!> helps normalizing Action's tokens for use as Python parameter names
+#ifdef HAVE_INLINE
+  inline
+#endif
+  std::string normalizeToken(std::string _token) {
+    std::replace(_token.begin(), _token.end(), '-', '_');
+    return _token;
+  }
+} /* namespace MoleCuilder */
 
 /** Nicely visible short-hand for push a status message
Index: src/Actions/Action_impl_pre.hpp
===================================================================
--- src/Actions/Action_impl_pre.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Actions/Action_impl_pre.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -173,8 +173,10 @@
     output << \
     BOOST_PP_IF(n, ", ", "") \
+    << normalizeToken( BOOST_PP_SEQ_ELEM(n, paramtokens) ) \
+    << "=" \
     << "\"" << params. \
         BOOST_PP_SEQ_ELEM(n, paramreferences) \
-        .getAsStringUnvalidated() \
-    << "\"";
+          .getAsStringUnvalidated() \
+    << "\""; \
 
 // print an initialiser list, i.e. "var( token, valid (,default) )(,)"
Index: src/Actions/Action_impl_python.hpp
===================================================================
--- src/Actions/Action_impl_python.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Actions/Action_impl_python.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -77,5 +77,5 @@
   BOOST_PP_COMMA_IF(n) \
   boost::python::arg( \
-  BOOST_PP_SEQ_ELEM(n, STRINGLIST) \
+		  MoleCuilder::normalizeToken( BOOST_PP_SEQ_ELEM(n, STRINGLIST) ).c_str() \
   ) \
   = \
@@ -92,5 +92,5 @@
   BOOST_PP_COMMA_IF(n) \
   boost::python::arg( \
-  BOOST_PP_SEQ_ELEM(n, STRINGLIST) \
+		  MoleCuilder::normalizeToken( BOOST_PP_SEQ_ELEM(n, STRINGLIST) ).c_str() \
   )
 
Index: src/Actions/MakroAction_impl_pre.hpp
===================================================================
--- src/Actions/MakroAction_impl_pre.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Actions/MakroAction_impl_pre.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -165,4 +165,6 @@
     output << \
     BOOST_PP_IF(n, ", ", "") \
+	  << normalizeToken( BOOST_PP_SEQ_ELEM(n, paramtokens) ) \
+	  << "=" \
     << "\"" << params. \
         BOOST_PP_SEQ_ELEM(n, paramreferences) \
Index: src/Atom/atom_atominfo.cpp
===================================================================
--- src/Atom/atom_atominfo.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Atom/atom_atominfo.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -191,9 +191,9 @@
 {
   OBSERVE;
-  NOTIFY(AtomObservable::PositionChanged);
   VectorTrajectory_t::iterator iter = AtomicPosition.find(_step);
   if (iter !=  AtomicPosition.end()) {
     iter->second[i] = value;
   } else {
+    NOTIFY(TrajectoryChanged);
     Vector newPos;
     newPos[i] = value;
@@ -206,4 +206,6 @@
         +" present after all?");
   }
+  if (WorldTime::getTime() == _step)
+    NOTIFY(AtomObservable::PositionChanged);
 }
 
@@ -278,4 +280,5 @@
     iter->second = _newvelocity;
   } else {
+    NOTIFY(TrajectoryChanged);
 #ifndef NDEBUG
     std::pair<VectorTrajectory_t::iterator, bool> inserter =
@@ -320,4 +323,5 @@
     iter->second = _newforce;
   } else {
+    NOTIFY(TrajectoryChanged);
 #ifndef NDEBUG
     std::pair<VectorTrajectory_t::iterator, bool> inserter =
Index: src/Parser/TremoloParser.cpp
===================================================================
--- src/Parser/TremoloParser.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/Parser/TremoloParser.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -510,4 +510,8 @@
       << currentAtom->GetTrueFather()->getId() << " at time step " << _timestep);
 
+  // note down default precision
+  std::streamsize defaultprecision=file->precision();
+  std::streamsize highprecision=10;
+
   for (usedFields_t::iterator it = usedFields_save.begin(); it != usedFields_save.end(); it++) {
     currentField = knownKeys[it->substr(0, it->find("="))];
@@ -516,21 +520,27 @@
         // for the moment, assume there are always three dimensions
         LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getPositionAtStep(_timestep));
+	file->precision(highprecision);
         *file << currentAtom->atStep(0, _timestep) << "\t";
         *file << currentAtom->atStep(1, _timestep) << "\t";
         *file << currentAtom->atStep(2, _timestep) << "\t";
+	file->precision(defaultprecision);
         break;
       case TremoloKey::u :
         // for the moment, assume there are always three dimensions
         LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicVelocityAtStep(_timestep));
+	file->precision(highprecision);
         *file << currentAtom->getAtomicVelocityAtStep(_timestep)[0] << "\t";
         *file << currentAtom->getAtomicVelocityAtStep(_timestep)[1] << "\t";
         *file << currentAtom->getAtomicVelocityAtStep(_timestep)[2] << "\t";
+	file->precision(defaultprecision);
         break;
       case TremoloKey::F :
         // for the moment, assume there are always three dimensions
         LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicForceAtStep(_timestep));
+	file->precision(highprecision);
         *file << currentAtom->getAtomicForceAtStep(_timestep)[0] << "\t";
         *file << currentAtom->getAtomicForceAtStep(_timestep)[1] << "\t";
         *file << currentAtom->getAtomicForceAtStep(_timestep)[2] << "\t";
+	file->precision(defaultprecision);
         break;
       case TremoloKey::type :
Index: src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -89,4 +89,8 @@
 QtObservedAtom::AtomPositionChannels(1, AtomObservable::PositionChanged);
 const Observable::channels_t
+QtObservedAtom::AtomVelocityChannels(1, AtomObservable::VelocityChanged);
+const Observable::channels_t
+QtObservedAtom::AtomForceChannels(1, AtomObservable::ForceChanged);
+const Observable::channels_t
 QtObservedAtom::AtomSelectedChannels(1, AtomObservable::SelectionChanged);
 
@@ -124,4 +128,6 @@
   boost::any_cast<ObservedValue_wCallback<std::string, ObservedValue_Index_t> *>(ObservedValues[AtomName])->noteCallBackIsGone();
   boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomPosition])->noteCallBackIsGone();
+  boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomVelocity])->noteCallBackIsGone();
+  boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomForce])->noteCallBackIsGone();
   boost::any_cast<ObservedValue_wCallback<bool, ObservedValue_Index_t> *>(ObservedValues[AtomSelected])->noteCallBackIsGone();
 
@@ -215,4 +221,22 @@
 inline
 #endif
+Vector QtObservedAtom::updateVelocity(
+    const atom &_atom)
+{
+  return _atom.getAtomicVelocity();
+}
+
+#ifdef HAVE_INLINE
+inline
+#endif
+Vector QtObservedAtom::updateForce(
+    const atom &_atom)
+{
+  return _atom.getAtomicForce();
+}
+
+#ifdef HAVE_INLINE
+inline
+#endif
 bool QtObservedAtom::updateSelected(
     const atom &_atom)
@@ -269,8 +293,14 @@
     boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
         ObservedValues[AtomPosition])->forceUpdate();
+    boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
+        ObservedValues[AtomVelocity])->forceUpdate();
+    boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(
+        ObservedValues[AtomForce])->forceUpdate();
     boost::any_cast<ObservedValue_wCallback<QtObservedMolecule*, ObservedValue_Index_t> *>(
         ObservedValues[MoleculeRef])->forceUpdate();
     // then tell Qt part about updates
     emit positionChanged();
+    emit velocityChanged();
+    emit forceChanged();
     emit moleculeChanged();
   } else {
@@ -296,4 +326,10 @@
       case AtomObservable::PositionChanged:
         emit positionChanged();
+        break;
+      case AtomObservable::VelocityChanged:
+        emit velocityChanged();
+        break;
+      case AtomObservable::ForceChanged:
+        emit forceChanged();
         break;
       case AtomObservable::SelectionChanged:
@@ -362,4 +398,8 @@
   const boost::function<Vector ()> AtomPositionUpdater(
       boost::bind(&QtObservedAtom::updatePosition, boost::cref(*_atomref)));
+  const boost::function<Vector ()> AtomVelocityUpdater(
+      boost::bind(&QtObservedAtom::updateVelocity, boost::cref(*_atomref)));
+  const boost::function<Vector ()> AtomForceUpdater(
+      boost::bind(&QtObservedAtom::updateForce, boost::cref(*_atomref)));
   const boost::function<bool ()> AtomSelectedUpdater(
       boost::bind(&QtObservedAtom::updateSelected, boost::cref(*_atomref)));
@@ -401,4 +441,18 @@
       AtomPositionUpdater(),
       AtomPositionChannels,
+      _subjectKilled);
+  _ObservedValues[AtomVelocity] = new ObservedValue_wCallback<Vector, ObservedValue_Index_t>(
+      _atomref,
+      AtomVelocityUpdater,
+      "AtomVelocity_"+toString(_id),
+      AtomVelocityUpdater(),
+      AtomVelocityChannels,
+      _subjectKilled);
+  _ObservedValues[AtomForce] = new ObservedValue_wCallback<Vector, ObservedValue_Index_t>(
+      _atomref,
+      AtomForceUpdater,
+      "AtomForce_"+toString(_id),
+      AtomForceUpdater(),
+      AtomForceChannels,
       _subjectKilled);
   _ObservedValues[AtomSelected] = new ObservedValue_wCallback<bool, ObservedValue_Index_t>(
@@ -426,4 +480,6 @@
   delete boost::any_cast<ObservedValue_wCallback<std::string, ObservedValue_Index_t> *>(_ObservedValues[AtomName]);
   delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomPosition]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomVelocity]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(_ObservedValues[AtomForce]);
   delete boost::any_cast<ObservedValue_wCallback<bool, ObservedValue_Index_t> *>(_ObservedValues[AtomSelected]);
   delete boost::any_cast<ObservedValue_wCallback<QtObservedMolecule*, ObservedValue_Index_t> *>(_ObservedValues[MoleculeRef]);
@@ -463,4 +519,14 @@
 }
 
+const Vector& QtObservedAtom::getAtomVelocity() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomVelocity])->get();
+}
+
+const Vector& QtObservedAtom::getAtomForce() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector, ObservedValue_Index_t> *>(ObservedValues[AtomForce])->get();
+}
+
 const bool QtObservedAtom::getAtomSelected() const
 {
Index: src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -136,4 +136,16 @@
   const Vector& getAtomPosition() const;
 
+  /** Getter to atom velocity contained in \a ObservedValues.
+   *
+   * \return atom's velocity
+   */
+  const Vector& getAtomVelocity() const;
+
+  /** Getter to atom force contained in \a ObservedValues.
+   *
+   * \return atom's force
+   */
+  const Vector& getAtomForce() const;
+
   /** Getter to the observed state of the associated molecule.
    *
@@ -155,4 +167,6 @@
   void nameChanged();
   void positionChanged();
+  void velocityChanged();
+  void forceChanged();
   void atomRemoved();
   void selectedChanged();
@@ -174,4 +188,6 @@
   static std::string updateName(const atom &_atom);
   static Vector updatePosition(const atom &_atom);
+  static Vector updateVelocity(const atom &_atom);
+  static Vector updateForce(const atom &_atom);
   static bool updateSelected(const atom &_atom);
 
@@ -188,4 +204,8 @@
     //!> contains the current atom position
     AtomPosition,
+    //!> contains the current atom velocity
+    AtomVelocity,
+    //!> contains the current atom force
+    AtomForce,
     //!> contains the current atom's selection status
     AtomSelected,
@@ -253,4 +273,8 @@
   //!> list of channels when position needs to update
   static const Observable::channels_t AtomPositionChannels;
+  //!> list of channels when velocity needs to update
+  static const Observable::channels_t AtomVelocityChannels;
+  //!> list of channels when force needs to update
+  static const Observable::channels_t AtomForceChannels;
   //!> list of channels when selection needs to update
   static const Observable::channels_t AtomSelectedChannels;
Index: src/UIElements/Qt4/QtMainWindow.hpp
===================================================================
--- src/UIElements/Qt4/QtMainWindow.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Qt4/QtMainWindow.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -32,4 +32,5 @@
 class QtMoleculeList;
 class QtShapeController;
+class QtTimeLine;
 class StringView;
 class GLWorldView;
@@ -38,5 +39,4 @@
 class QtToolBar;
 class QCloseEvent;
-class QSlider;
 
 class QtObservedInstanceBoard;
@@ -70,5 +70,5 @@
   QtMenu<QMenuBar> *MainMenu;
   QtToolBar *toolbar;
-  QSlider *timeline;
+  QtTimeLine *timeline;
   QtLogBox *logBox;
   QtLogBox *errorlogBox;
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -61,8 +61,11 @@
 QGLMaterial *GLMoleculeObject::m_selectionMaterial = NULL;
 QGLMaterial *GLMoleculeObject::m_selectionBoxMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_velocityMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_forceMaterial = NULL;
 
 QGLSceneNode *GLMoleculeObject::meshEmpty[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshSphere[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshCylinder[GLMoleculeObject::DETAILTYPES_MAX];
+QGLSceneNode *GLMoleculeObject::meshArrow[GLMoleculeObject::DETAILTYPES_MAX];
 
 double GLMoleculeObject::detailMinDistance[GLMoleculeObject::DETAILTYPES_MAX] = {0, 15, 30, 42};
@@ -309,4 +312,14 @@
     m_selectionBoxMaterial->setEmittedLight( QColor(155, 50, 50) );
   }
+  if (!m_velocityMaterial){
+    m_velocityMaterial = new QGLMaterial(NULL);
+    QColor colorvelocity(50,50,255,255);
+    m_velocityMaterial->setColor(colorvelocity);
+  }
+  if (!m_forceMaterial){
+    m_forceMaterial = new QGLMaterial(NULL);
+    QColor colorforce(50,255,50,255);
+    m_forceMaterial->setColor(colorforce);
+  }
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -108,4 +108,5 @@
    static QGLSceneNode *meshSphere[DETAILTYPES_MAX];
    static QGLSceneNode *meshCylinder[DETAILTYPES_MAX];
+   static QGLSceneNode *meshArrow[DETAILTYPES_MAX];
 
 protected:
@@ -130,4 +131,6 @@
    static QGLMaterial *m_selectionMaterial;
    static QGLMaterial *m_selectionBoxMaterial;
+   static QGLMaterial *m_velocityMaterial;
+   static QGLMaterial *m_forceMaterial;
    QGLAbstractEffect *m_effect;
    int m_objectId;
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -50,4 +50,5 @@
 #include "Element/element.hpp"
 #include "Element/periodentafel.hpp"
+#include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/Vector.hpp"
 #include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp"
@@ -57,7 +58,10 @@
 GLMoleculeObject_atom::GLMoleculeObject_atom(
     QGLSceneNode *mesh[],
+    QGLSceneNode *mesharrow[],
     QObject *parent,
     QtObservedAtom::ptr &_ObservedAtom) :
   GLMoleculeObject(mesh, parent),
+  GLMoleculeObjectVelocity(mesharrow, this),
+  GLMoleculeObjectForce(mesharrow, this),
   ObservedAtom(_ObservedAtom)
 {
@@ -69,5 +73,10 @@
   setObjectId(_id);
   resetPosition();
+  resetVelocity();
+  resetForce();
   resetElement();
+
+  GLMoleculeObjectVelocity.setMaterial(GLMoleculeObject::m_velocityMaterial);
+  GLMoleculeObjectForce.setMaterial(GLMoleculeObject::m_forceMaterial);
 
   m_selected = ObservedAtom->getAtomSelected();
@@ -77,4 +86,6 @@
   connect( ObservedAtom.get(), SIGNAL(elementChanged()), this, SLOT(resetElement()));
   connect( ObservedAtom.get(), SIGNAL(positionChanged()), this, SLOT(resetPosition()));
+  connect( ObservedAtom.get(), SIGNAL(velocityChanged()), this, SLOT(resetVelocity()));
+  connect( ObservedAtom.get(), SIGNAL(forceChanged()), this, SLOT(resetForce()));
   connect( ObservedAtom.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
 }
@@ -95,4 +106,15 @@
 }
 
+static void setArrow(
+    const Vector &_position,
+    const Vector &_arrow,
+    const double _offset,
+    GLMoleculeObject &_obj)
+{
+  // set position (cylinder offset is in its barymetric center)
+  Vector OneFourth(_position + (_offset/_arrow.Norm()+.75) * _arrow);
+  _obj.setPosition(QVector3D(OneFourth[0], OneFourth[1], OneFourth[2]));
+}
+
 void GLMoleculeObject_atom::resetPosition()
 {
@@ -100,4 +122,57 @@
   LOG(4, "INFO: GLMoleculeObject_atom::resetPosition() - new position is "+toString(Position)+".");
   setPosition(QVector3D(Position[0], Position[1], Position[2]));
+  setArrow(Position, 10.*ObservedAtom->getAtomVelocity(), scaleX(), GLMoleculeObjectVelocity);
+  setArrow(Position, 10.*ObservedAtom->getAtomForce(), scaleX(), GLMoleculeObjectForce);
+}
+
+static void alignArrow(
+    const Vector &_arrow,
+    GLMoleculeObject &_obj)
+{
+  if (_arrow.IsZero()) {
+    _obj.setScaleZ(0.);
+    return;
+  }
+  // calculate position
+  Vector Z(unitVec[2]); // cylinder are initially aligned along the Z axis
+  Vector b;
+  Vector OtherAxis;
+  double alpha;
+  // construct rotation axis
+  b = -1.*_arrow;
+  b.VectorProduct(Z);
+  Line axis(zeroVec, b);
+  // calculate rotation angle
+  alpha = _arrow.Angle(Z);
+  // construct other axis to check right-hand rule
+  OtherAxis = b;
+  OtherAxis.VectorProduct(Z);
+  // assure right-hand rule for the rotation
+  if (_arrow.ScalarProduct(OtherAxis) < MYEPSILON)
+    alpha = M_PI-alpha;
+  // check
+  Vector a_rotated = axis.rotateVector(_arrow, alpha);
+  LOG(5, "DEBUG: Aligning arrow " << _arrow << " to " << a_rotated
+      << " around " << b << " by " << alpha/M_PI*180. << ".");
+
+  _obj.setScaleZ(10.*_arrow.Norm());
+  _obj.setRotationVector(QVector3D(b[0], b[1], b[2]));
+  _obj.setRotationAngle(alpha/M_PI*180.);
+}
+
+void GLMoleculeObject_atom::resetVelocity()
+{
+  const Vector Velocity = ObservedAtom->getAtomVelocity();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetVelocity() - new velocity is "+toString(Velocity)+".");
+  alignArrow(Velocity, GLMoleculeObjectVelocity);
+//  GLMoleculeObjectForce.setScaleZ(Velocity.Norm());
+}
+
+void GLMoleculeObject_atom::resetForce()
+{
+  const Vector Force = ObservedAtom->getAtomForce();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetForce() - new force is "+toString(Force)+".");
+  alignArrow(Force, GLMoleculeObjectForce);
+//  GLMoleculeObjectForce.setScaleZ(Force.Norm());
 }
 
@@ -144,4 +219,6 @@
   // call old hook to do the actual paining
   GLMoleculeObject::draw(painter, cameraPlane);
+  GLMoleculeObjectVelocity.draw(painter, cameraPlane);
+  GLMoleculeObjectForce.draw(painter, cameraPlane);
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -34,4 +34,5 @@
   GLMoleculeObject_atom(
       QGLSceneNode *mesh[],
+      QGLSceneNode *mesharrow[],
       QObject *parent,
       QtObservedAtom::ptr &_ObservedAtom
@@ -46,4 +47,6 @@
   void resetElement();
   void resetPosition();
+  void resetVelocity();
+  void resetForce();
   void resetSelected();
 
@@ -58,4 +61,9 @@
 
 private:
+  //!> internal GLMoleculeObject to represent the atom's velocity as an arrow
+  GLMoleculeObject GLMoleculeObjectVelocity;
+  //!> internal GLMoleculeObject to represent the atom's force as an arrow
+  GLMoleculeObject GLMoleculeObjectForce;
+
   //!> current list of bonds to compare new onw against for changes
   QtObservedAtom::ListOfBonds_t ListOfBonds;
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -154,4 +154,5 @@
   int sphereDetails[] = {5, 3, 2, 0};
   int cylinderDetails[] = {16, 8, 6, 3};
+  int arrowDetails[] = {8, 5, 3, 0};
   for (int i=0;i<GLMoleculeObject::DETAILTYPES_MAX;i++){
     QGLBuilder emptyBuilder;
@@ -165,4 +166,21 @@
     GLMoleculeObject::meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
     GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    {
+      QGLBuilder builderCyl;
+      builderCyl << QGLCylinder(.15,.15,1.6,arrowDetails[i]);
+      QGLSceneNode *cyl = builderCyl.finalizedSceneNode();
+      QGLBuilder builderCone;
+      builderCone << QGLCylinder(0,.4,0.4,arrowDetails[i]);
+      QGLSceneNode *cone = builderCone.finalizedSceneNode();
+      {
+        QMatrix4x4 mat;
+        mat.translate(0.0f, 0.0f, 1.0f);
+        cone->setLocalTransform(mat);
+      }
+      GLMoleculeObject::meshArrow[i] = new QGLSceneNode(this);
+      GLMoleculeObject::meshArrow[i]->addNode(cyl);
+      GLMoleculeObject::meshArrow[i]->addNode(cone);
+    }
+    GLMoleculeObject::meshArrow[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
   connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
@@ -279,4 +297,5 @@
     atomObject = new GLMoleculeObject_atom(
             GLMoleculeObject::meshSphere,
+            GLMoleculeObject::meshArrow,
             parent,
             _atom);
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -93,9 +93,9 @@
 //  connect(this, SIGNAL(TimeChanged()), worldscene, SIGNAL(updated()));
   connect(worldscene, SIGNAL(changeOccured()), this, SLOT(changeSignalled()));
-  connect(worldscene, SIGNAL(changed()), this, SIGNAL(changed()));
+  connect(this, SIGNAL(changed()), this, SLOT(changeSignalled()));
   connect(worldscene, SIGNAL(hoverChanged(const atomId_t)), this, SLOT(sceneHoverSignalled(const atomId_t)));
   connect(worldscene, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SLOT(sceneHoverSignalled(const moleculeId_t, int)));
   //connect(this, SIGNAL(changed()), this, SLOT(updateGL()));
-  connect(this, SIGNAL(changed()), this, SLOT(sceneChangeSignalled()));
+  connect(worldscene, SIGNAL(changed()), this, SLOT(sceneChangeSignalled()));
   connect(this, SIGNAL(moleculesVisibilityChanged(ObservedValue_Index_t,bool)),
       worldscene, SLOT(moleculesVisibilityChanged(ObservedValue_Index_t,bool)));
@@ -104,4 +104,6 @@
   WorldTime::getInstance().signOn(this, WorldTime::TimeChanged);
   AtomObserver::getInstance().signOn(this, AtomObservable::PositionChanged);
+  AtomObserver::getInstance().signOn(this, AtomObservable::VelocityChanged);
+  AtomObserver::getInstance().signOn(this, AtomObservable::ForceChanged);
 
   ShapeRegistry::getInstance().signOn(this);
@@ -124,4 +126,6 @@
   WorldTime::getInstance().signOff(this, WorldTime::TimeChanged);
   AtomObserver::getInstance().signOff(this, AtomObservable::PositionChanged);
+  AtomObserver::getInstance().signOff(this, AtomObservable::VelocityChanged);
+  AtomObserver::getInstance().signOff(this, AtomObservable::ForceChanged);
   ShapeRegistry::getInstance().signOff(this);
   ShapeRegistry::getInstance().signOff(this, ShapeRegistry::ShapeInserted);
@@ -341,4 +345,5 @@
       observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that WorldTime's time has changed.";
 #endif
+        needsRedraw = false;
         emit changed();
         emit TimeChanged();
@@ -353,4 +358,5 @@
       case ShapeRegistry::ShapeInserted:
       {
+        needsRedraw = false;
         emit ShapeAdded(ShapeRegistry::getInstance().lastChanged()->getName());
         break;
@@ -358,4 +364,5 @@
       case ShapeRegistry::ShapeRemoved:
       {
+        needsRedraw = false;
         emit ShapeRemoved(ShapeRegistry::getInstance().lastChanged()->getName());
         break;
@@ -363,4 +370,5 @@
       case ShapeRegistry::SelectionChanged:
       {
+        needsRedraw = false;
         worldscene->updateSelectedShapes();
         break;
@@ -375,6 +383,6 @@
 void GLWorldView::checkChanges()
 {
+  needsRedraw = false;
   updateGL();
-  needsRedraw = false;
 }
 
@@ -385,6 +393,6 @@
   setdreiBeinStatus(!status);
   // realize
-  updateGL();
   needsRedraw = true;
+  emit changed();
 }
 
@@ -403,6 +411,6 @@
   setDomainStatus(!status);
   // realize
-  updateGL();
   needsRedraw = true;
+  emit changed();
 }
 
@@ -417,5 +425,5 @@
 void GLWorldView::sceneChangeSignalled()
 {
-  if (!needsRedraw){
+  if (needsRedraw){
     redrawTimer->singleShot(0, this, SLOT(checkChanges()));
     needsRedraw = true;
@@ -432,8 +440,6 @@
 void GLWorldView::paintGL(QGLPainter *painter)
 {
-  if (changesPresent) {
+  if (changesPresent)
     initializeGL(painter);
-    changesPresent = false;
-  }
 
   QVector3D cameraDir = camera()->center() - camera()->eye();
@@ -492,4 +498,5 @@
 {
   changesPresent = true;
+  updateGL();
 }
 
@@ -548,5 +555,5 @@
   setStereoType(QGLView::Hardware);
   camera()->setEyeSeparation(0.0);
-  updateGL();
+  emit changed();
 }
 
@@ -555,5 +562,5 @@
   setStereoType(QGLView::Hardware);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -562,5 +569,5 @@
   setStereoType(QGLView::LeftRight);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -569,5 +576,5 @@
   setStereoType(QGLView::RightLeft);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -576,5 +583,5 @@
   setStereoType(QGLView::TopBottom);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -583,5 +590,5 @@
   setStereoType(QGLView::BottomTop);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -590,5 +597,5 @@
   setStereoType(QGLView::RedCyanAnaglyph);
   camera()->setEyeSeparation(defaultEyeSeparation);
-  updateGL();
+  emit changed();
 }
 
@@ -714,4 +721,6 @@
 void GLWorldView::sceneHoverSignalled(const atomId_t _id)
 {
+  needsRedraw = true;
+  emit changed();
   emit hoverChanged(_id);
 }
@@ -719,4 +728,6 @@
 void GLWorldView::sceneHoverSignalled(const moleculeId_t _id, int _i)
 {
+  needsRedraw = true;
+  emit changed();
   emit hoverChanged(_id, _i);
 }
Index: src/UIElements/Views/Qt4/QtInfoBox.cpp
===================================================================
--- src/UIElements/Views/Qt4/QtInfoBox.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/QtInfoBox.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -65,5 +65,5 @@
 
   setMinimumWidth(200);
-  setMinimumHeight(220);
+  setMinimumHeight(350);
 
   connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeout()));
@@ -220,4 +220,10 @@
   addInfo(this, "Position y", QString(toString(atomRef->getAtomPosition()[1]).c_str()));
   addInfo(this, "Position z", QString(toString(atomRef->getAtomPosition()[2]).c_str()));
+  addInfo(this, "Velocity x", QString(toString(atomRef->getAtomVelocity()[0]).c_str()));
+  addInfo(this, "Velocity y", QString(toString(atomRef->getAtomVelocity()[1]).c_str()));
+  addInfo(this, "Velocity z", QString(toString(atomRef->getAtomVelocity()[2]).c_str()));
+  addInfo(this, "Force x", QString(toString(atomRef->getAtomForce()[0]).c_str()));
+  addInfo(this, "Force y", QString(toString(atomRef->getAtomForce()[1]).c_str()));
+  addInfo(this, "Force z", QString(toString(atomRef->getAtomForce()[2]).c_str()));
 }
 
Index: src/UIElements/Views/Qt4/QtTimeLine.cpp
===================================================================
--- src/UIElements/Views/Qt4/QtTimeLine.cpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/QtTimeLine.cpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -47,18 +47,27 @@
 
 QtTimeLine::QtTimeLine(QWidget * _parent) :
-    QSlider (Qt::Horizontal, _parent),
+    QWidget(_parent),
     Observer("QtTimeLine"),
     atomobserver_enlisted(false),
     worldtime_enlisted(false),
-    WorldTime_change(false)
+    SetWorldTime_called(false)
 {
+  slider = new QSlider(Qt::Horizontal, this);
   // set initial values
-  QSlider::setMinimum(0);
-  QSlider::setMaximum(0);
-  WorldTime_change = true;
-  QSlider::setValue(0);
-  QSlider::setTickInterval(1);
-  QSlider::setSingleStep(1);
-  QSlider::setTracking(true);
+  slider->setMinimum(0);
+  slider->setMaximum(0);
+  slider->setValue(0);
+  slider->setTickInterval(1);
+  slider->setSingleStep(1);
+  slider->setTracking(true);
+
+  spinbox = new QSpinBox(this);
+  spinbox->setMinimum(0);
+  spinbox->setMaximum(0);
+  spinbox->setValue(0);
+
+  layout = new QHBoxLayout(this);
+  layout->addWidget(slider);
+  layout->addWidget(spinbox);
 
   // sign on to observable
@@ -69,5 +78,6 @@
 
   // connect to QSlider's valueChanged() signal
-  bool result = connect(this,SIGNAL(valueChanged(int)),this,SLOT(StepUpdate(int)), Qt::DirectConnection);
+  bool result = connect(slider,SIGNAL(valueChanged(int)),this,SLOT(StepUpdate(int)));
+  result = result && connect(spinbox,SIGNAL(valueChanged(int)),this,SLOT(StepUpdate(int)));
   if (!result)
     ELOG(0, "Could not connect to QSlider::valueChanged.");
@@ -86,5 +96,5 @@
   boost::recursive_mutex::scoped_lock lock(refill_mutex);
 
-  QSlider::paintEvent(event);
+//  layout->paintEvent(event);
 }
 
@@ -111,11 +121,14 @@
 
   if (static_cast<WorldTime *>(publisher) == WorldTime::getPointer()) {
+    SetWorldTime_called = false;
     const int timestep = WorldTime::getTime();
     // check whether we are beyond maximum
-    if (timestep > QSlider::maximum())
-      QSlider::setMaximum(timestep);
+    if (timestep > slider->maximum()) {
+      slider->setMaximum(timestep);
+      spinbox->setMaximum(timestep);
+    }
     // set slider position to new time step
-    WorldTime_change = true;
-    QSlider::setValue( timestep );
+    slider->setValue( timestep );
+    spinbox->setValue( timestep );
   } else
     //if (static_cast<AtomObserver *>(publisher) == AtomObserver::getPointer())
@@ -124,6 +137,8 @@
     const atom *_atom = dynamic_cast<const atom *>(publisher);
     const int MaxTrajectory = _atom->getTrajectorySize()-1;
-    if (MaxTrajectory > QSlider::maximum())
-      QSlider::setMaximum(MaxTrajectory);
+    if (MaxTrajectory > slider->maximum()) {
+      slider->setMaximum(MaxTrajectory);
+      spinbox->setMaximum(MaxTrajectory);
+    }
   }
 }
@@ -133,7 +148,9 @@
   boost::recursive_mutex::scoped_lock lock(refill_mutex);
 
-  if (WorldTime_change)
-    WorldTime_change = false;
-  else
-    MoleCuilder::WorldSetWorldTime(position);
+  if (!SetWorldTime_called) {
+    if (WorldTime::getTime() != (unsigned int)position) {
+      SetWorldTime_called = true;
+      MoleCuilder::WorldSetWorldTime(position);
+    }
+  }
 }
Index: src/UIElements/Views/Qt4/QtTimeLine.hpp
===================================================================
--- src/UIElements/Views/Qt4/QtTimeLine.hpp	(revision 3e334eccad1a8fd1f8d4dd9744f081736bbce250)
+++ src/UIElements/Views/Qt4/QtTimeLine.hpp	(revision 8d56a66db031fb7242c20ad2e8df56f7593755b6)
@@ -14,5 +14,7 @@
 #endif
 
+#include <QtGui/QHBoxLayout>
 #include <QtGui/QSlider>
+#include <QtGui/QSpinBox>
 
 #include <boost/thread/recursive_mutex.hpp>
@@ -20,5 +22,5 @@
 #include "CodePatterns/Observer/Observer.hpp"
 
-class QtTimeLine : public QSlider, public Observer
+class QtTimeLine : public QWidget, public Observer
 {
   Q_OBJECT
@@ -42,6 +44,11 @@
   //!> whether WorldTime knows about us or not
   bool worldtime_enlisted;
-  //!> states whether value was set by observing WorldTime (and not by slider)
-  bool WorldTime_change;
+
+  QSlider *slider;
+  QSpinBox *spinbox;
+  QHBoxLayout *layout;
+
+  //!> states whether we are expecting a notification from the worldtime
+  bool SetWorldTime_called;
 
   mutable boost::recursive_mutex refill_mutex;
