diff --git a/src/Lib/Script/Ast/IrExpression.cc b/src/Lib/Script/Ast/IrExpression.cc
index 1d519fb1c9974aeefc4c6eb99e2d2703324ee904..35979377b7e9bf07aa71d7bda7abcef045ce7dcf 100644
--- a/src/Lib/Script/Ast/IrExpression.cc
+++ b/src/Lib/Script/Ast/IrExpression.cc
@@ -62,22 +62,88 @@ IrEVariableRef::parse(std::vector<Token> *)
 }
 }
 
+/*
+** IrEConstExpr
+*/
+
 namespace Vivy::Script
 {
 IrEConstExpr::IrEConstExpr(const Token &singleElement)
     : IrExpression(nullptr, Type::ConstExpr)
 {
-    throw std::logic_error("IrEConstExpr " + singleElement.toString());
+    switch (singleElement.valueType()) {
+    case Token::Type::INTEGER:
+    case Token::Type::FLOATING:
+    case Token::Type::COLORLIT:
+    case Token::Type::STRINGLIT:
+
+    /* Only handle true or false */
+    case Token::Type::SIMPLE: {
+        if (singleElement.isSimple(TOKEN_FALSE)) {
+            selfInnerType = IrElement::create<IrTPrimitive>(this, IrType::PrimitiveType::Bool);
+        } else if (singleElement.isSimple(TOKEN_TRUE)) {
+            selfInnerType = IrElement::create<IrTPrimitive>(this, IrType::PrimitiveType::Bool);
+        } else {
+            throw std::logic_error("IrEConstExpr unexpected simple token: " + singleElement.toString() + ", expected `true` or `false`");
+        }
+    }
+
+    case Token::Type::QNAME:
+    default: {
+        throw std::logic_error("IrEConstExpr unexpected token: " + singleElement.toString());
+    }
+    }
+}
+
+IrTPrimitive *IrTPrimitive::innerType() const noexcept
+{
+    return dynamic_cast<IrTPrimitive*>(IrType::innerType());
+}
+
+bool  IrEConstExpr::getInnerBoolean() const
+{
+    selfInnerType->assertType(IrType::PrimitiveType::Bool);
+    return inner.boolean;
+}
+
+int   IrEConstExpr::getInnerInteger() const
+{
+    selfInnerType->assertType(IrType::PrimitiveType::Integer);
+    return inner.integer;
+}
+
+float IrEConstExpr::getInnerFloating() const
+{
+    selfInnerType->assertType(IrType::PrimitiveType::Floating);
+    return inner.floating;
+}
+
+StrV  IrEConstExpr::getInnerStringLit() const
+{
+    selfInnerType->assertType(IrType::PrimitiveType::String);
+    return inner.string;
+}
+
+StrV  IrEConstExpr::getInnerColorLit() const
+{
+    selfInnerType->assertType(IrType::PrimitiveType::Color);
+    return inner.string;
 }
 
 std::string
 IrEConstExpr::toString() const noexcept
 {
-    return "IrEConstExpr";
+    switch (innerType()->innerType()) {
+        case IrType::PrimitiveType::Color:  return inner.string.toStdStrng();
+        case IrType::PrimitiveType::String: return inner.string.toStdStrng();
+        case IrType::PrimitiveType::Integer: return std::to_string(inner.integer);
+        case IrType::PrimitiveType::Floating: return std::to_string(inner.floating);
+        case IrType::PrimitiveType::Bool: return inner.boolean ? std::string("true") : std::string("false");
+    }
 }
 
 void
-IrEConstExpr::parse(std::vector<Token> *)
+IrEConstExpr::parse(std::vector<Token> *tokens)
 {
     throw std::logic_error("Not implemented");
 }
diff --git a/src/Lib/Script/Ast/IrExpression.hh b/src/Lib/Script/Ast/IrExpression.hh
index 9261515bdd9e2ce296235e14cb9722538fc35618..42c151bde7d7222b74f3533f7e252a25b5263c51 100644
--- a/src/Lib/Script/Ast/IrExpression.hh
+++ b/src/Lib/Script/Ast/IrExpression.hh
@@ -22,7 +22,7 @@ public:
     void parse(std::vector<Token> *) override;
 
     Type type() const noexcept;
-    IrType *innerType() const noexcept;
+    virtual IrType *innerType() const noexcept;
 };
 
 class IrEConstExpr : public IrExpression {
@@ -30,9 +30,25 @@ class IrEConstExpr : public IrExpression {
 
     IrEConstExpr(const Token &);
 
+    union {
+        bool boolean;
+        int integer;
+        float floating;
+
+        /* StringLit + ColorLit */
+        StrV string;
+    } inner;
+
 public:
     std::string toString() const noexcept override;
     void parse(std::vector<Token> *) override;
+    IrTPrimitive *innerType() const override noexcept;
+
+    bool getInnerBoolean() const;
+    int getInnerInteger() const;
+    float getInnerFloating() const;
+    StrV getInnerStringLit() const;
+    StrV getInnerColorLit() const;
 };
 
 class IrECall : public IrExpression {
diff --git a/src/Lib/Script/Ast/IrType.cc b/src/Lib/Script/Ast/IrType.cc
index 009a1f0ee1b81c10db1f10d44574261b23ed6f83..4860a1c52533a73843d6f40beb097fbde3d48281 100644
--- a/src/Lib/Script/Ast/IrType.cc
+++ b/src/Lib/Script/Ast/IrType.cc
@@ -15,6 +15,14 @@ IrType::parent() noexcept
 {
     return dynamic_cast<IrVariable *>(IrElement::parent());
 }
+
+void
+IrType::assertType(Type t) const
+{
+    if (type() != t) {
+        throw std::runtime_error("Type differs from asked type, this is " + std::to_string(type()) + " and asked " + std::to_string(t));
+    }
+}
 }
 
 namespace Vivy::Script
@@ -76,8 +84,23 @@ IrTOption::parse(std::vector<Token> *)
 }
 }
 
+/*
+** IrTPrimitive
+*/
+
 namespace Vivy::Script
 {
+IrTPrimitive::IrTPrimitive(const PrimitiveType type, unsigned int size) noexcept
+    : selfInnerType(type)
+    , selfArraySize(size)
+{
+}
+
+IrTPrimitive::IrTPrimitive(const PrimitiveType type) noexcept
+    : IrTPrimitive(type, 1)
+{
+}
+
 IrTPrimitive::IrTPrimitive(const Token &name)
 {
     throw std::logic_error("IrTPrimitive " + name.toString());
diff --git a/src/Lib/Script/Ast/IrType.hh b/src/Lib/Script/Ast/IrType.hh
index d74b60250dcc6b8ff7e3b3f5740da5a9cfb69de4..71b2b5b36842e3c43dacd2d54780d70294880a5e 100644
--- a/src/Lib/Script/Ast/IrType.hh
+++ b/src/Lib/Script/Ast/IrType.hh
@@ -11,15 +11,16 @@ class IrType : public IrElement {
 public:
     enum struct Type { Ass, Option, Primitive };
     enum struct AssType { Line, Syllabe };
-    enum struct PrimitiveType { Int, Float, Bool, Color };
+    enum struct PrimitiveType { Int, Float, Bool, Color, String };
 
 public:
     virtual Type type() const noexcept = 0;
+    void assertType(Type) const;
     const IrVariable *parent() const noexcept override;
     IrVariable *parent() noexcept override;
 };
 
-class IrTAss : public IrType {
+class IrTAss final : public IrType {
     VIVY_IR_ELEMENT(IrTAss)
 
     AssType selfType;
@@ -34,7 +35,7 @@ public:
     void parse(std::vector<Token> *) override;
 };
 
-class IrTOption : public IrType {
+class IrTOption final : public IrType {
     VIVY_IR_ELEMENT(IrTOption)
 
     IrOption *selfInnerOption;
@@ -47,13 +48,15 @@ public:
     void parse(std::vector<Token> *) override;
 };
 
-class IrTPrimitive : public IrType {
+class IrTPrimitive final : public IrType {
     VIVY_IR_ELEMENT(IrTPrimitive)
 
     PrimitiveType selfInnerType;
     unsigned int selfArraySize;
 
     IrTPrimitive(const Token &);
+    IrTPrimitive(const PrimitiveType) noexcept;
+    IrTPrimitive(const PrimitiveType, unsigned int) noexcept;
 
 public:
     Type type() const noexcept override;