diff --git a/apps/sequence/cache_context.cpp b/apps/sequence/cache_context.cpp
index 1a9a88a47..1e284a751 100644
--- a/apps/sequence/cache_context.cpp
+++ b/apps/sequence/cache_context.cpp
@@ -8,7 +8,7 @@ namespace Sequence {
 
 template<typename T>
 CacheContext<T>::CacheContext(Context * parentContext) :
-  VariableContext<T>("n", parentContext),
+  VariableContext("n", parentContext),
   m_values{{NAN, NAN},
     {NAN, NAN}}
 {
@@ -21,7 +21,7 @@ const Expression CacheContext<T>::expressionForSymbol(const Symbol & symbol) {
    && (strcmp(symbol.name()+1, "(n)") == 0 || strcmp(symbol.name()+1, "(n+1)") == 0)) {
     return Float<T>(m_values[nameIndexForSymbol(symbol)][rankIndexForSymbol(symbol)]);
   }
-  return VariableContext<T>::expressionForSymbol(symbol);
+  return VariableContext::expressionForSymbol(symbol);
 }
 
 template<typename T>
diff --git a/apps/sequence/cache_context.h b/apps/sequence/cache_context.h
index a11430998..0157cde4e 100644
--- a/apps/sequence/cache_context.h
+++ b/apps/sequence/cache_context.h
@@ -10,7 +10,7 @@
 namespace Sequence {
 
 template<typename T>
-class CacheContext : public Poincare::VariableContext<T> {
+class CacheContext : public Poincare::VariableContext {
 public:
   CacheContext(Poincare::Context * parentContext);
   const Poincare::Expression expressionForSymbol(const Poincare::Symbol & symbol) override;
diff --git a/poincare/include/poincare/function.h b/poincare/include/poincare/function.h
index 116cb4463..9128a9c46 100644
--- a/poincare/include/poincare/function.h
+++ b/poincare/include/poincare/function.h
@@ -25,8 +25,7 @@ public:
   float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const override;
 
 private:
-  template<typename T>
-  VariableContext<T> xContext(Context & parentContext) const;
+  VariableContext xContext(Context & parentContext) const;
   // Layout
   Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
   int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
diff --git a/poincare/include/poincare/variable_context.h b/poincare/include/poincare/variable_context.h
index 4f1e1033a..36d0694e1 100644
--- a/poincare/include/poincare/variable_context.h
+++ b/poincare/include/poincare/variable_context.h
@@ -6,10 +6,10 @@
 
 namespace Poincare {
 
-template<typename T>
 class VariableContext : public Context {
 public:
   VariableContext(const char * name, Context * parentContext = nullptr);
+  template<typename T>
   void setApproximationForVariable(T value);
 
   // Context
@@ -18,7 +18,7 @@ public:
 
 private:
   const char * m_name;
-  Float<T> m_value;
+  Expression m_value;
   Context * m_parentContext;
 };
 
diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp
index 94924c711..4752ee89a 100644
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -330,8 +330,8 @@ U Expression::approximateToScalar(const char * text, Context& context, Preferenc
 
 template<typename U>
 U Expression::approximateWithValueForSymbol(const char * symbol, U x, Context & context, Preferences::AngleUnit angleUnit) const {
-  VariableContext<U> variableContext = VariableContext<U>(symbol, &context);
-  variableContext.setApproximationForVariable(x);
+  VariableContext variableContext = VariableContext(symbol, &context);
+  variableContext.setApproximationForVariable<U>(x);
   return approximateToScalar<U>(variableContext, angleUnit);
 }
 
diff --git a/poincare/src/function.cpp b/poincare/src/function.cpp
index 5cd279ea2..a8e589167 100644
--- a/poincare/src/function.cpp
+++ b/poincare/src/function.cpp
@@ -10,32 +10,31 @@ namespace Poincare {
 int FunctionNode::polynomialDegree(Context & context, const char * symbolName) const {
   Expression e = context.expressionForSymbol(Function(this));
 /*TODO Context should be float or double ?*/
-  VariableContext<float> newContext = xContext<float>(context);
+  VariableContext newContext = xContext(context);
   return e.polynomialDegree(newContext, symbolName);
 }
 
 int FunctionNode::getPolynomialCoefficients(Context & context, const char * symbolName, Expression coefficients[]) const {
   Expression e = context.expressionForSymbol(Function(this));
-  VariableContext<float> newContext = xContext<float>(context);
+  VariableContext newContext = xContext(context);
   return e.getPolynomialCoefficients(newContext, symbolName, coefficients);
 }
 
 int FunctionNode::getVariables(Context & context, isVariableTest isVariable, char * variables[], int maxSizeVariable) const {
   Expression e = context.expressionForSymbol(Function(this));
-  VariableContext<float> newContext = xContext<float>(context);
+  VariableContext newContext = xContext(context);
   return e.getVariables(newContext, isVariable, variables, maxSizeVariable);
 }
 
 float FunctionNode::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const {
   Expression e = context.expressionForSymbol(Function(this));
-  VariableContext<float> newContext = xContext<float>(context);
+  VariableContext newContext = xContext(context);
   return e.characteristicXRange(newContext, angleUnit);
 }
 
-template<typename T>
-VariableContext<T> FunctionNode::xContext(Context & parentContext) const {
+VariableContext FunctionNode::xContext(Context & parentContext) const {
   const char x[] = {Symbol::SpecialSymbols::UnknownX, 0};
-  VariableContext<T> xContext = VariableContext<T>(x, &parentContext);
+  VariableContext xContext = VariableContext(x, &parentContext);
   xContext.setExpressionForSymbolName(Expression(childAtIndex(0)), x, xContext);
   return xContext;
 }
@@ -54,13 +53,13 @@ Expression FunctionNode::shallowReduce(Context & context, Preferences::AngleUnit
 
 Evaluation<float> FunctionNode::approximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const {
   Expression e = context.expressionForSymbol(Function(this));
-  VariableContext<float> newContext = xContext<float>(context);
+  VariableContext newContext = xContext(context);
   return e.approximateToEvaluation<float>(newContext, angleUnit);
 }
 
 Evaluation<double> FunctionNode::approximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const {
   Expression e = context.expressionForSymbol(Function(this));
-  VariableContext<double> newContext = xContext<double>(context);
+  VariableContext newContext = xContext(context);
   return e.approximateToEvaluation<double>(newContext, angleUnit);
 }
 
diff --git a/poincare/src/sequence.cpp b/poincare/src/sequence.cpp
index 851cdb08c..2d1f8f4de 100644
--- a/poincare/src/sequence.cpp
+++ b/poincare/src/sequence.cpp
@@ -24,13 +24,13 @@ Evaluation<T> SequenceNode::templatedApproximate(Context& context, Preferences::
   if (std::isnan(start) || std::isnan(end) || start != (int)start || end != (int)end || end - start > k_maxNumberOfSteps) {
     return Complex<T>::Undefined();
   }
-  VariableContext<T> nContext = VariableContext<T>("n", &context);
+  VariableContext nContext = VariableContext("n", &context);
   Evaluation<T> result = Complex<T>((T)emptySequenceValue());
   for (int i = (int)start; i <= (int)end; i++) {
     if (Expression::shouldStopProcessing()) {
       return Complex<T>::Undefined();
     }
-    nContext.setApproximationForVariable((T)i);
+    nContext.setApproximationForVariable<T>((T)i);
     result = evaluateWithNextTerm(T(), result, childAtIndex(0)->approximate(T(), nContext, angleUnit));
     if (result.isUndefined()) {
       return Complex<T>::Undefined();
diff --git a/poincare/src/variable_context.cpp b/poincare/src/variable_context.cpp
index 49dd041c0..672483373 100644
--- a/poincare/src/variable_context.cpp
+++ b/poincare/src/variable_context.cpp
@@ -6,33 +6,30 @@
 
 namespace Poincare {
 
-template<typename T>
-VariableContext<T>::VariableContext(const char * name, Context * parentContext) :
+VariableContext::VariableContext(const char * name, Context * parentContext) :
   m_name(name),
-  m_value(Float<T>(NAN)),
+  m_value(),
   m_parentContext(parentContext)
 {
 }
 
 template<typename T>
-void VariableContext<T>::setApproximationForVariable(T value) {
+void VariableContext::setApproximationForVariable(T value) {
   m_value = Float<T>(value);
 }
 
-template<typename T>
-void VariableContext<T>::setExpressionForSymbolName(const Expression & expression, const char * symbolName, Context & context) {
+void VariableContext::setExpressionForSymbolName(const Expression & expression, const char * symbolName, Context & context) {
   if (strcmp(symbolName, m_name) == 0) {
     if (expression.isUninitialized()) {
       return;
     }
-    m_value = Float<T>(expression.approximateToScalar<T>(context, Preferences::sharedPreferences()->angleUnit()));
+    m_value = expression.clone();
   } else {
     m_parentContext->setExpressionForSymbolName(expression, symbolName, context);
   }
 }
 
-template<typename T>
-const Expression VariableContext<T>::expressionForSymbol(const Symbol & symbol) {
+const Expression VariableContext::expressionForSymbol(const Symbol & symbol) {
   if (strcmp(symbol.name(), m_name) == 0) {
     return m_value;
   } else {
@@ -40,7 +37,7 @@ const Expression VariableContext<T>::expressionForSymbol(const Symbol & symbol)
   }
 }
 
-template class Poincare::VariableContext<float>;
-template class Poincare::VariableContext<double>;
+template void VariableContext::setApproximationForVariable(float);
+template void VariableContext::setApproximationForVariable(double);
 
 }