diff --git a/texla/Parser/Blocks/Block.py b/texla/Parser/Blocks/Block.py
index 206d8b1..3c45e17 100644
--- a/texla/Parser/Blocks/Block.py
+++ b/texla/Parser/Blocks/Block.py
@@ -1,134 +1,133 @@
 from .Utilities import *
 
 
 """Base Block definition"""
 class Block:
     """
     Block general attributes:
     -block_name: the new of the "type" of the block
     -id: unique id for the block in the tree
     -parent_block: parent in the tree
     -attributes: a dictionary for description of the block.
         All useful parser data go into attributes
     -ch_blocks: a list of children_blocks
     -section_level: the position of the block compared to
         sectioning levels defined in utility.py
 
     Derived Block could add more attributes.
     """
 
     @staticmethod
     def parse(parser, tex, parent_block, params):
         """
         The method must return a tuple with the created
         Block and the last used index of tex string."""
         pass
 
 
     def __init__(self, block_name, content, parent_block):
         """
         Base constructor for Block.
         It saves the parent_block and block name and create
         the new id for the new block. It creates data structures
         like the attributed dictionary and children nodes list.
         It always saves a content variable.
         By default, it sets the section_level of the block
         to that of the parend_block.
         """
         self.block_name = block_name
         self.content = content
         if not parent_block is None:
             self.parent_block = parent_block
             self.id = parent_block.id + '-' + utility.get_random_string(3)
             #Section level:
             #by default the level is the same of parent block
             self.section_level = self.parent_block.section_level
             #depth in the tree
             self.tree_depth = self.parent_block.tree_depth+1
         else:
             #if this is the root block
             self.parent_block = None
             self.id = '@'
             self.section_level = -1
             self.tree_depth = 0
         #dictionary for attributes
-        self.attributes = {'N_chblocks' : 0}
+        self.attributes = {}
         #list for childrend blocks
         self.ch_blocks = []
         self.N_chblocks = 0
 
 
     def add_child_block(self, block):
         """
         IMPORTANT: this function is called by the self.parse fuction.
         It MUST NOT be called from outside, expecially the parser
         """
         self.ch_blocks.append(block)
         self.N_chblocks +=1
-        self.attributes['N_chblocks']+=1
 
     def add_children_blocks(self, blocks):
         """
         IMPORTANT: this function is called by the self.parse fuction.
         It MUST NOT be called from outside, expecially the parser
         """
         self.ch_blocks += blocks
         self.N_chblocks +=len(blocks)
-        self.attributes['N_chblocks']+=len(blocks)
 
     def change_parent_block(self, new_parent):
         """s function changes the parent of the
         block. It changes parent object, id, and tree_depth.
         The section level is not changes for consistency.
         All children are updated.
-        """      
+        """
         self.parent_block = new_parent
         #rebuiding id
         self.id = new_parent.id + '-' + utility.get_random_string(3)
         #the section level is not changed,
         #but tree_depth is updated
         self.tree_depth = new_parent. tree_depth + 1
         #now childrens are updated
         for ch in self.ch_blocks:
             ch.change_parent_block(self)
 
     def get_children(self, bl_name):
         """ This function return a list of children blocks
         corresponding to the requested type. If there are not
         children blocks of that type it returns a void list."""
         result = []
         for bl in self.ch_blocks:
             if bl.block_name == bl_name:
                 result.append(bl)
         return result
 
     def __str__(self):
         return '<Block:{}, ID:{}>'.format( self.block_name, self.id)
 
     def to_json(self, level=0):
         """
         This functions create a json ouput that
         represents the tree of subblocks of the called block.
         """
         json = ''
         levelb = level+3
         json += (' '*level + '{\n')
         json += (' '*levelb + '"ID":"'+ self.id+'",\n')
         json += (' '*levelb + '"block_name":"'+ self.block_name+'",\n')
+        json += (' '*levelb + '"N. ch_blocks":"'+ str(self.N_chblocks)+'",\n')
         json += (' '*levelb + '"tree_depth":"'+ str(self.tree_depth)+'",\n')
         for k,v in self.attributes.items():
             json += (' '*levelb + '"'+k+ '":"'+str(v)+ '",\n' )
         json += (' '*levelb + '"children_blocks":[\n')
         for b in self.ch_blocks:
             json+= b.to_json(levelb+3)
         json += (' '*levelb+'],\n')
         json += (' '*level + '}\n')
         return json
 
     def n_blocks(self):
         """s function returns the
-        number of all children blocks recursively."""      
+        number of all children blocks recursively."""
         n = len(self.ch_blocks)
         for c in self.ch_blocks:
             n+= c.n_blocks()
         return n
diff --git a/texla/Parser/Blocks/DefaultBlock.py b/texla/Parser/Blocks/DefaultBlock.py
index 0bdc4c8..90d4f20 100644
--- a/texla/Parser/Blocks/DefaultBlock.py
+++ b/texla/Parser/Blocks/DefaultBlock.py
@@ -1,49 +1,50 @@
 '''Default Block'''
 import logging
 from .Utilities import *
 from .Block import Block
 
 class DefaultBlock(Block):
 	''' This Block is used when the parser doesn't find
 	a proper parser_hook to call for a matched env or command'''
 
 	@staticmethod
 	def parse_env(parser ,tex, parent_block, params):
 		#getting the name of env
 		if 'env' in params:
 			env_name = params['env']
 		else:
 			env_name = 'no_env'
 		if 'star' in params:
 			env_name = env_name + '*' if params['star'] else env_name
 		#default block is created
 		block = DefaultBlock(tex, env_name, parent_block)
 		#We cannot look inside tex, we don't know
 		#what to parser.
 		#we return the block
 		return block
 
 	@staticmethod
 	def parse_cmd(parser ,tex, parent_block, params):
 		cmd = params['cmd']
 		cmd = cmd + '*' if params['star'] else cmd
 		#the options has to be matched from the tex
 		match = CommandParser.get_command_options(tex)
 		#match is (options string, left tex
 		ptex = '\\'+cmd+match[0]
 		#default block is created
 		block = DefaultBlock(ptex, cmd, parent_block)
 		#we return the block and the left tex to parse
 		return (block, match[1])
 
 	def __init__(self, tex, block_name, parent_block):
 		super().__init__('default', tex, parent_block)
 		#the tex is added also as attribute
 		self.type = block_name
-		self.attributes['content'] = tex
+		self.attributes["type"] = block_name
+        #the content is already saved by the base block
 
 
 parser_hooks = {
 	'default_env' : DefaultBlock.parse_env,
 	'default_cmd' : DefaultBlock.parse_cmd,
 	}
diff --git a/texla/Parser/Blocks/MathBlocks.py b/texla/Parser/Blocks/MathBlocks.py
index 85e47a7..d00b7cc 100644
--- a/texla/Parser/Blocks/MathBlocks.py
+++ b/texla/Parser/Blocks/MathBlocks.py
@@ -1,83 +1,97 @@
 import logging
 import re
 from .Utilities import *
 from .ReferenceBlocks import LabelBlock
 from .Block import Block
 
 class MathBlock(Block):
 
     @staticmethod
     def parse_math_env(parser, tex, parent_block, params):
         ''' This parse hook it's used for $$, $, \[ \( and
         general math environments'''
         env = params['env']
         star = params.get('star',False)
         #getting labels and tex without labels
         tex, labels = MathBlock.parse_labels(tex)
         #the content of the math is stripped
         block = MathBlock(env, star, tex.strip(), parent_block)
         #creating and adding labels blocks
         for l in labels:
             lblock = LabelBlock(l, block)
             logging.debug('BLOCK @ %s%s',
                     "\t"*lblock.tree_depth, str(lblock))
             block.labels.append(lblock)
         return block
 
     @staticmethod
     def parse_ensure_math(parser, tex, parent_block, params):
         ''' The \ensuremath{} is a math command, not env'''
         options, left_tex = CommandParser.parse_options(tex,
             [('math','{','}')])
         text = options['math']
         block = MathBlock('ensuremath', False, text, parent_block)
         return (block, left_tex)
 
+    @staticmethod
+    def parse_empheq(parser, tex, parent_block, params):
+        '''We need to extract the right environment from the options '''
+        options, content = CommandParser.parse_options(tex,
+                [("emph_opt","[","]"), ("env", "{","}")])
+        env = options["env"]
+        star = False
+        if env.endswith("*"):
+            env = env[:-1]
+            star = True
+        block = MathBlock(env, star, content, parent_block)
+        return block
+
+
     @staticmethod
     def parse_labels(tex):
         '''
         The function get labels from math.
         Multiple labels in math are allowed.
         It creates a list of Label mathced and removes
         them from the tex.
         It returns the modified tex and list of labels.
         '''
         lre = re.compile(r'\\label\s*\{(?P<label>.*?)\}')
         labels = []
         for m in lre.finditer(tex):
             labels.append(m.group('label'))
             #removing label from tex
             tex = tex.replace(m.group(), '')
         return (tex, labels)
 
 
     def __init__(self, math_type, star, tex, parent_block):
         super().__init__(math_type, tex, parent_block)
         #the type and content is saved both as attribute and instance member
         self.math_type = math_type
         self.attributes['math_type'] = math_type
         #the content is saved in attributes
         self.attributes['content'] = tex
         self.attributes['star'] = star
         #list for labels blocks
         self.labels = []
 
     def __str__(self):
         return  '<Block:{}, ID:{}, math_type:{}, star:{}>'.format(
             self.block_name, self.id, self.attributes['math_type'],
             self.attributes['star'])
 
 
 parser_hooks = {
     'inlinemath' : MathBlock.parse_math_env,
     'displaymath' : MathBlock.parse_math_env,
     'equation' : MathBlock.parse_math_env,
     'align' : MathBlock.parse_math_env,
     'eqnarray' : MathBlock.parse_math_env,
     'multline' : MathBlock.parse_math_env,
     'alignat' : MathBlock.parse_math_env,
     'gather' : MathBlock.parse_math_env,
     'ensuremath' : MathBlock.parse_ensure_math,
-    'empheq' : MathBlock.parse_math_env,
+    'empheq' : MathBlock.parse_empheq,
     'math': MathBlock.parse_math_env
 }
diff --git a/texla/Parser/TreeExplorer.py b/texla/Parser/TreeExplorer.py
index 2a829d2..e6ff2b7 100644
--- a/texla/Parser/TreeExplorer.py
+++ b/texla/Parser/TreeExplorer.py
@@ -1,120 +1,122 @@
 import logging
 
 class TreeExplorer:
     """
     The TreeExplorer class is an utility to navigate
     and extract information from the tree of parsed blocks.
     For example it is useful to extract the tree of the
     parents of a block for debugging reasons. It is useful
     also in rendering to localize blocks inside the document.
     """
 
     def __init__(self, root_block):
         """ The constructor needs a root_block to
         begin the tree"""
         self.root_block = root_block
         self.blocks = {'@': root_block}
         self.block_names = {}
         #registering blocks by id
         self.register_blocks(root_block.ch_blocks)
 
     @staticmethod
     def create_tree_from_children(block):
         #first of all we need the root_block
         current = block
         while True:
             if current.parent_block is None:
                 root_block = current
                 break
             current = current.parent_block
         #now we can return a new TreeExplorer
         #constructed from the found root.
         return TreeExplorer(root_block)
 
     def register_blocks(self, blocks):
         """This methods reads all the blocks tree
         from the root_block and created a dictionary
         with id:block"""
         for block in blocks:
             self.blocks[block.id] = block
             if block.N_chblocks > 0:
                 self.register_blocks(block.ch_blocks)
 
     def update_blocks_register(self):
         """This methods update the blocks' ids register
         recalling register_blocks with the root_block"""
         self.register_blocks(self.root_block.ch_blocks)
 
     def get_parents_list(self, block):
         """This method returns the list of the parent
         blocks of the requested block """
         if isinstance(block, str):
             block = self.blocks[block]
         parents = []
         current = block
         while True:
             if current == self.root_block:
                 break
             parents.append(current.parent_block)
             current = current.parent_block
         parents.reverse()
         return parents
 
     def get_parents_list_ids(self, block):
         parents = self.get_parents_list(block)
         return [x.id for x in parents]
 
     def get_block(self, blockid):
         return self.blocks.get(blockid)
 
     def print_tree(self, block, filter_list=None):
         """This methods prints a beautified tree starting
         from block parameter and his children. If filter_list
         is present only the block with the id in the list
         are printed. It returns a list of output strings"""
         output = []
         if filter_list is None or block.id in filter_list:
             lstr = ".    "* (block.tree_depth+1)
             output.append(lstr+ ".   "+ "  "+"_"*40 )
             output.append(lstr+ "#"+"---"+ ">|ID : {}".format(block.id))
             output.append(lstr+ ".   "+ " |block_name : {}".
                           format(block.block_name))
             output.append(lstr+ ".   "+ " |attributes: ")
             for at,attr in block.attributes.items():
                 output.append(lstr+ ".   " + " |   - "+ "{} : {}".
                               format(at, attr))
+            output.append(lstr+ ".   "+ " |content : {}".
+                        format(block.content))
             output.append(lstr+ ".    ."+"\u203E"*40+"\n")
         output = "\n".join(output)
         #iterating on the block children
         for bl in block.ch_blocks:
             output += self.print_tree(bl, filter_list)
         return output
 
     def print_tree_to_blocks(self, blocks):
         """This methods print the tree of parents
         of the list of blocks passed as parameter.
         First of all it gets all the parents ids and
         then prints the tree using the list as filter."""
         fl = []
         for bl in blocks:
             fl+= self.get_parents_list_ids(bl)
             if isinstance(bl, str):
                 fl.append(bl)
             else:
                 fl.append(bl.id)
         return self.print_tree(self.root_block, filter_list=fl)
 
     def print_tree_to_block(self, block):
         return self.print_tree_to_blocks([block])
 
     def print_all_tree(self):
         return self.print_tree(self.root_block)
 
     def register_block_names(self):
         """This function registers the block_names, creating
          a dictionary with blocks groups by type"""
         self.block_names.clear()
         for bl in self.blocks.values():
             if not bl in self.block_names:
                 self.block_names[bl.block_name] = []
-            self.block_names[bl.block_name].append(bl)
\ No newline at end of file
+            self.block_names[bl.block_name].append(bl)
diff --git a/texla/Renderers/MediaWikiRenderer.py b/texla/Renderers/MediaWikiRenderer.py
index 78c219c..53edb97 100644
--- a/texla/Renderers/MediaWikiRenderer.py
+++ b/texla/Renderers/MediaWikiRenderer.py
@@ -1,579 +1,577 @@
 import logging
 from .Renderer import Renderer
 from ..PageTree.PageTree import *
 
 class MediaWikiRenderer(Renderer):
 
     def __init__(self, configs, reporter):
-        super().__init__(reporter)
+        super().__init__(configs, reporter)
         self.configs = configs
         self.doc_title = configs['doc_title']
         #saving the hooks
         self.render_hooks = {
             #root
             'root-block': self.r_document,
             'default': self.default,
             #text
             'par': self.r_par,
             'newpage': self.r_newpage,
             'newline': self.r_newline,
             '\\': self.r_newline,
             'text': self.r_text,
             'clearpage': self.r_newpage,
             'cleardoublepage': self.r_newpage,
             #formatting
             'emph': self.r_textit,
             'textbf': self.r_textbf,
             'textit': self.r_textit,
             'textsc': self.r_textsc,
             'textsuperscript': self.r_superscript,
             'textsubscript': self.r_subscript,
             'underline': self.r_underline,
             'uline': self.r_underline,
             '%': self.r_special_character,
             '&': self.r_special_character,
             '$': self.r_special_character,
             '{': self.r_special_character,
             '}': self.r_special_character,
             '#': self.r_special_character,
             '_': self.r_special_character,
             'dots': self.r_dots,
             'ldots': self.r_dots,
             'flushright': self.r_flushright,
             'flushleft': self.r_flushleft,
             'center': self.r_center,
             'centerline': self.r_center,
             'abstract': self.r_abstract,
             'linebreak': self.r_break,
             'pagebreak': self.r_break,
             'nolinebreak': self.r_break,
             'nopagebreak': self.r_break,
             'verbatim': self.r_verbatim,
             'verb': self.r_verb,
             #spaces
             'vspace': self.r_vspace,
             'mandatory_space': self.r_mandatory_space,
             #theorems
             'theorem' : self.r_theorem,
             'proof' : self.r_proof,
             #sectioning
             'part': self.sectioning,
             'chapter': self.sectioning,
             'section': self.sectioning,
             'subsection': self.sectioning,
             'subsubsection': self.sectioning,
             'paragraph': self.sectioning,
             'subparagraph': self.sectioning,
             #math
             'displaymath': self.r_display_math,
             'inlinemath': self.r_inline_math,
             'ensuremath': self.r_inline_math,
             'equation': self.r_display_math,
             'eqnarray': self.r_align,
             'multline': self.r_align,
             'align': self.r_align,
             'alignat': self.r_align,
             'gather': self.r_gather,
             #lists
             'itemize': self.r_itemize,
             'enumerate': self.r_enumerate,
             'description': self.r_description,
             #quotes
             'quotation': self.r_quotes,
             'quote': self.r_quotes,
             'verse': self.r_verse,
             'footnote': self.r_footnote,
             #labels
             'label': self.r_label,
             'ref': self.r_ref,
             'vref': self.r_ref,
             'pageref': self.r_ref,
             'eqref': self.r_ref,
             #accents
             "accented_letter": self.r_accented_letter,
             #figures
             "figure": self.r_figure
             }
-        #register plugins
-        self.register_plugins(configs["plugins"])
         #tree object
         self.tree = PageTree(configs)
         #parameter for list formatting
         self.list_level = ''
         #parameters for theorem handling
         self.in_theorem = False
         self.theorem_number = 0
         self.th_numbering = {}
 
     ########################################
     #STARTING POINT
 
     def start_rendering(self, root_block):
         """starting rendering from root-block"""
         #start rendering of base class
         super(MediaWikiRenderer, self).start_rendering(root_block)
         self.render_block(root_block)
         #after rendering
         self.tree.after_render()
         #end rendering of base class
         super(MediaWikiRenderer, self).end_rendering()
 
     ####### ROOT BLOCK
     def r_document(self, block):
         #we trigger the rendering of content
         text = self.render_children_blocks(block)
         #text is the tex outside sections
         self.tree.addText(text)
         #returning the text to respect the interface
         return text
 
     ########################################
     #DEFAULT
 
     def default(self, block):
         #we don't print anything
         return ''
 
     #########################################
     #TEXT
 
     def r_text(self, block):
         text = block.attributes['text']
-        
+
         # The following replace happens as ~ is the latex symbol
         # for unbreakable space
         return text.replace("~", " ")
 
     def r_newline(self, block):
         return '\n'
 
     def r_newpage(self, block):
         return '\n\n'
 
     def r_par(self, block):
         return '\n\n'
 
     #########################################
     #SECTIONING
 
     def sectioning(self, block):
         title = block.attributes['title']
         section_name = block.attributes['section_name']
         #remove the \n insiede title
         title = re.sub('\\n*', '', title)
         #creation of the new page
         self.tree.createPage(title, section_name)
         #content processing
         text = self.render_children_blocks(block)
         #adding text to current page
         self.tree.addText(text)
         #exiting the section
         self.tree.exitPage()
         return ''
 
     #########################################
     #MATH
 
     def r_display_math(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math display="block">' + s + '</math>'
 
     def r_inline_math(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math>' + s + '</math>'
 
     def r_align(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math display="block">\\begin{align}' +\
                     s + '\end{align}</math>'
 
     def r_gather(self, block):
         s = block.attributes['content']
         output = []
         for eq in s.split("\\\\"):
             eq = eq.replace("\n","").strip()
             output.append('<math display="block">' +\
                         eq + '</math>')
         #rendering labels
         self.render_blocks(block.labels)
         return '\n'.join(output)
 
 
     #########################################
     #LABELS and refs
 
     def r_label(self, block):
         label = block.attributes['label']
         self.tree.addLabel(label)
         return ''
 
     def r_ref(self, block):
         ref = block.attributes['ref']
         #saving ref in Babel of PageTree
         self.tree.addReference(ref)
         return "{{ref@"+ ref+ "}}"
 
     #########################################
     #FIGURE
 
     def r_figure(self, block):
         captions = block.get_children("caption")
         includegraphics = block.get_children("includegraphics")
         s = "[[File:"
         if len(includegraphics):
             inc = includegraphics[0]
             s += inc.attributes["img_name"]
         else:
             return ""
         if len(block.get_children("centering")):
                 s += "|" + self.configs["keywords"]["center"]
 
         if len(captions):
             cap = captions[0]
             s += "|" + cap.attributes["caption"]
         s += "]]"
         return s;
 
 
 
     #########################################
     #FORMATTING
 
     def r_special_character(self, block):
         return block.attributes['character']
 
     def r_dots(self, block):
         return '...'
 
     def r_textbf(self, block):
         s = []
         s.append("\'\'\'")
         s.append(self.render_children_blocks(block))
         s.append("\'\'\'")
         return ''.join(s)
 
     def r_textit(self, block):
         s = []
         s.append("\'\'")
         s.append(self.render_children_blocks(block))
         s.append("\'\'")
         return ''.join(s)
 
     def r_textsc(self, block):
         return self.render_children_blocks(block).upper()
 
     def r_superscript(self, block):
         s = []
         s.append('<sup>')
         s.append(self.render_children_blocks(block))
         s.append('</sup>')
         return ''.join(s)
 
     def r_subscript(self, block):
         s = []
         s.append('<sub>')
         s.append(self.render_children_blocks(block))
         s.append('</sub>')
         return ''.join(s)
 
     def r_underline(self, block):
         s = []
         s.append('{{Sottolineato|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_abstract(self, block):
         s = []
         s.append('{{Abstract|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_break(self, block):
         return ''
 
     def r_vspace(self,block):
         return '\n\n'
 
     def r_mandatory_space(self,block):
         return ' '
 
     def r_verbatim(self, block):
         return '<pre>' + block.attributes['content'] +'</pre>'
 
     def r_verb(self, block):
         return '<tt>' + block.attributes['content'] +'</tt>'
 
     #########################################
     #ALIGNMENT
 
     def r_center(self, block):
         s = []
         s.append('{{Center|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_flushleft(self, block):
         s = []
         s.append('{{Flushleft|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_flushright(self, block):
         s = []
         s.append('{{Flushright|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     #########################################
     #LISTS
 
     def r_itemize(self, block):
         self.list_level += '*'
         s = ['\n']
         for item in block.ch_blocks:
             s.append(self.list_level)
             s.append(self.render_children_blocks(item).strip())
             s.append("\n")
         self.list_level = self.list_level[:-1]
         return ''.join(s)
 
     def r_enumerate(self, block):
         self.list_level += '#'
         s = ['\n']
         for item in block.ch_blocks:
             s.append(self.list_level)
             s.append(self.render_children_blocks(item).strip())
             s.append("\n")
         self.list_level = self.list_level[:-1]
         return ''.join(s)
 
     def r_description(self, block):
         s = ['\n']
         for item in block.ch_blocks:
             s.append(';')
             s.append(item.attributes['word'])
             s.append(':')
             s.append(self.render_children_blocks(item))
             s.append("\n")
         return ''.join(s)
 
     #########################################
     #QUOTES
 
     def r_quotes(self, block):
         s = []
         s.append('<blockquote>')
         s.append(self.render_children_blocks(block))
         s.append('</blockquote>')
         return ''.join(s)
 
     def r_verse(self, block):
         s = []
         s.append('<blockquote>')
         s.append('\n'.join(self.render_children_blocks(block).split('//')))
         s.append('</blockquote>')
         return ''.join(s)
 
     def r_footnote(self, block):
         s = []
         s.append("<ref>")
         s.append(self.render_children_blocks(block))
         s.append("</ref>")
         return ''.join(s)
 
     #########################################
     #Theorems
 
     def r_theorem(self, block):
         #the label in theorems is not working for now
         th_definition = block.attributes['definition']
         th_title = ''
         if block.attributes['title'] != None:
             th_title +=" "+ block.attributes['title']
         s = []
         #adding the theorem to the tree
         self.theorem_number += 1
         self.tree.addTheorem(str(self.theorem_number), th_definition)
         #checking if the Environment template is used
         environ = False
         if self.configs['lang'] =='it':
             if th_definition.lower() == 'teorema':
             #adding content to page through a template
                 s.append("\n{{InizioTeorema|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineTeorema}}\n")
             elif th_definition.lower() == 'definizione':
                 s.append("\n{{InizioDefinizione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDefinizione}}\n")
             elif th_definition.lower() == 'proposizione':
                 s.append("\n{{InizioProposizione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineProposizione}}\n")
             elif th_definition.lower() == 'lemma':
                 s.append("\n{{InizioLemma|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineLemma}}\n")
             elif th_definition.lower() == 'corollario':
                 s.append("\n{{InizioCorollario|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineCorollario}}\n")
             elif th_definition.lower()[:-2] == 'eserciz':
                 s.append("\n{{InizioEsercizio|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineEsercizio}}\n")
             elif th_definition.lower()[:-1] == 'osservazion':
                 s.append("\n{{InizioOsservazione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineOsservazione}}\n")
             elif th_definition.lower()[:-2] == 'esemp':
                 s.append("\n{{InizioEsempio|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineEsempio}}\n")
             elif th_definition.lower() == 'dimostrazione':
                 s.append("\n{{InizioDimostrazione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
             else:
                 s.append("\n{{Environment|name="+ th_definition + \
                         "|title=" + th_title +\
                         "|content=")
                 s.append(self.render_children_blocks(block))
                 s.append("}}\n")
         elif self.configs['lang'] =='en':
             if th_definition.lower() == 'theorem':
             #adding content to page through a template
                 s.append("\n{{BeginTheorem|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndTheorem}}\n")
             elif th_definition.lower() == 'definition':
                 s.append("\n{{BeginDefinition|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndDefinition}}\n")
             elif th_definition.lower() == 'proposition':
                 s.append("\n{{BeginProposition|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProposition}}\n")
             elif th_definition.lower() == 'lemma':
                 s.append("\n{{BeginLemma|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndLemma}}\n")
             elif th_definition.lower() == 'corollary':
                 s.append("\n{{BeginCorollary|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndCorollary}}\n")
             elif th_definition.lower() == 'exercise':
                 s.append("\n{{BeginExercise|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndExercise}}\n")
             elif th_definition.lower() == 'observation':
                 s.append("\n{{BeginObservation|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndObservation}}\n")
             elif th_definition.lower() == 'remark':
                 s.append("\n{{BeginRemark|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndRemark}}\n")
             elif th_definition.lower() == 'example':
                 s.append("\n{{BeginExample|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndExample}}\n")
             elif th_definition.lower() == 'demonstration':
                 s.append("\n{{BeginDemonstration|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndDemonstration}}\n")
             else:
                 s.append("\n{{Environment|name="+ th_definition + \
                         "|title=" + th_title +\
                         "|content=")
                 s.append(self.render_children_blocks(block))
                 s.append("}}\n")
         #exit from theorem ambient
         self.tree.exitTheorem()
         return '\n'.join(s)
 
     def r_proof(self, block):
         s=[]
         if self.configs['lang'] == 'it':
             if block.title !=None:
                 s.append('\n{{InizioDimostrazione|titolo='+\
                         block.attributes['title']+ "}}")
 
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
             else:
                 s.append('\n{{InizioDimostrazione}}')
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
         elif self.configs['lang'] == 'en':
             if block.title !=None:
                 s.append('\n{{BeginProof|title='+\
                         block.attributes['title']+"}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProof}}\n")
             else:
                 s.append('\n{{BeginProof}}')
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProof}}\n")
         return '\n'.join(s)
 
     #########################################
     #ACCENTED letters
     def r_accented_letter(self, block):
         if block.attributes["accent_type"] == '"' \
                 and block.attributes["letter"] == "a":
             return "ä"
         if block.attributes["accent_type"] in ["'","`"]:
             return block.attributes["letter"]+\
                     block.attributes["accent_type"]
         else:
             return block.attributes["letter"]
diff --git a/texla/Renderers/Renderer.py b/texla/Renderers/Renderer.py
index e127439..80c9888 100644
--- a/texla/Renderers/Renderer.py
+++ b/texla/Renderers/Renderer.py
@@ -1,178 +1,186 @@
 from ..Parser import Blocks
 from ..Parser.TreeExplorer import TreeExplorer
 import logging
 import importlib
 
 class Renderer():
-    def __init__(self, reporter):
+    def __init__(self, configs, reporter):
+        self.configs = configs
         self.reporter = reporter
         #hooks implemented directly by the Renderer class.
         self.render_hooks = {}
         #plugins hooks
         self.pre_render_hooks = {}
         self.post_render_hooks = {}
         self.start_hooks = []
         self.end_hooks = []
         self.loaded_plugins = {}
         self.tree_explorer = None
+        #registering plugins from the configs
+        self.register_plugins()
 
-    def register_plugins(self, plugins):
-        for plugin in plugins:
+    def register_plugins(self):
+        for plugin in self.configs["plugins"]:
             module = importlib.import_module("..plugins"+'.'+ plugin, __name__)
             if hasattr(module, "plugin_render_hooks"):
                 self.loaded_plugins[plugin] = module
                 self.register_render_plugin_hooks(module.plugin_render_hooks)
                 logging.debug("Renderer.register_plugins "\
                              "@ Loaded plugin: {}".format(plugin))
                 logging.debug("Plugin {} render hooks: {}".format( plugin,
                             list(module.plugin_render_hooks.keys())))
             if hasattr(module, "plugin_lifecycle_hooks"):
                 self.register_lifecyle_plugin_hooks(module.plugin_lifecycle_hooks)
                 logging.debug("Plugin {} lifecycle hooks: {}".format( plugin,
                             list(module.plugin_lifecycle_hooks.keys())))
+            #adding the configurations to the plugin
+            if "plugins_configs" in self.configs:
+                if plugin in self.configs["plugins_configs"]:
+                    logging.debug("Plugin {} passing configs...".format(plugin))
+                    module.configs = self.configs["plugins_configs"][plugin]
 
 
 
     def register_render_plugin_hooks(self, hooks):
         '''This function registers the hooks for renderer plugins.
         The plugins can define hooks for pre and post render actions.
         The pre hook receives the block before the rendering and can
         only return the block itself, modified.
         The post hook receive the block and the text from the renderer:
         it has to return the final text only.
         The keyword ALL creates a hooks for all the blocks.
         Note that it is always called after all the other hooks.'''
         for bl in hooks:
             if "pre" in hooks[bl]:
                 self.register_pre_renderer_hook(bl, hooks[bl]["pre"])
             if "post" in hooks[bl]:
                 self.register_post_renderer_hook(bl, hooks[bl]["post"])
         #checking ALL keyword
         if "ALL" in hooks:
             if "pre" in hooks["ALL"]:
                 self.register_pre_renderer_hook(bl, hooks["ALL"]["pre"])
             if "post" in hooks["ALL"]:
                 self.register_post_renderer_hook(bl, hooks["ALL"]["post"])
 
     def register_lifecyle_plugin_hooks(self, hooks):
         ''' This function registers the hooks for the renderer lifecycle.
         Plugins can register hooks for the start and end actions.
         The start hook is called with the root_block of the chain.
         The end hook is called without arguments. These hooks must be used
         only to signal the actions to the plugins.'''
         if "start" in hooks:
             self.register_start_hook(hooks["start"])
         if "end" in hooks:
             self.register_end_hook(hooks["end"])
 
     def register_pre_renderer_hook(self, block, hook):
         if block not in self.pre_render_hooks:
             self.pre_render_hooks[block] = []
         self.pre_render_hooks[block].append(hook)
 
     def register_post_renderer_hook(self, block, hook):
         if block not in self.post_render_hooks:
             self.post_render_hooks[block] = []
         self.post_render_hooks[block].append(hook)
 
     def register_start_hook(self, hook):
         self.start_hooks.append(hook)
 
     def register_end_hook(self, hook):
         self.end_hooks.append(hook)
 
     def start_rendering(self, root_block):
         '''This function create a TreeExplorer instance
         and passes it to the plugin that has the variable
         needs_tree_explorer=True. Then it starts the plugins'''
         self.tree_explorer = TreeExplorer(root_block)
         #passing the tree_explorer
         for pl in self.loaded_plugins.values():
             if hasattr(pl, "needs_tree_explorer"):
                 if pl.needs_tree_explorer:
                     logging.debug("Renderer @ Inserting "\
                                   "TreeExplorer into plugin {}".format(pl))
                     pl.tree_explorer = self.tree_explorer
         #starting the plugins
         for hook in self.start_hooks:
             hook(root_block)
 
     def end_rendering(self):
         #ending plugins
         for hook in self.end_hooks:
             hook()
 
     def render_children_blocks(self, block, collapse=True):
         '''This is one of the most important funciont
         of the rendering process.
         This function takes all the children blocks of
         a block and get they rendering output.
         If collapsed=True it returns a unique string,
         otherwise it returns a list of tuples with[(block_name, output)]
         '''
         output = []
         for bl in block.ch_blocks:
             #it's not necessary checking for renderer_hook
             #because default hook is mandatory
             output.append((bl.block_name, self.render_block(bl)))
         if collapse:
             return ''.join([x[1] for x in output])
         else:
             return output
 
     def render_block(self, bl):
         '''This function calls the right render_hook for
         the block. If there isn't an hook it calld the default,
         that is mandatory'''
         output = ""
         ######### pre hooks ############
         #hooks executed in the order of inserction
         #They receive the block and they can only modify the block object
         if bl.block_name in self.pre_render_hooks:
             for prehook in self.pre_render_hooks[bl.block_name]:
                 #calling prehook with the block
                 prehook(bl)
         #calling after the others the ALL hooks
         if "ALL" in self.pre_render_hooks:
             for prehook in self.pre_render_hooks["ALL"]:
                 #calling prehook with the block
                 prehook(bl)
         ######## rendering #############
         if bl.block_name in self.render_hooks:
             logging.debug('Render @ block: ' + bl.block_name)
             output = self.render_hooks[bl.block_name](bl)
         else:
             #default hook is mandatory
             logging.debug('Render @ block: default@' + bl.block_name)
             #reporting to the Reporter
             if bl.block_name != "default":
                 self.reporter.add_not_rendered_block(bl)
             output = self.render_hooks['default'](bl)
         ######## post hooks ###########
         #hooks executed in the order of inserction.
         #They receive the block and text. They have to return the
         #output text, that is passed to the next posthook
         if bl.block_name in self.post_render_hooks:
             for posthook in self.post_render_hooks[bl.block_name]:
                 #calling posthook with the block and output
                 output = posthook(bl, output)
         #calling ALL hooks after the others
         if "ALL" in self.post_render_hooks:
             for posthook in self.post_render_hooks["ALL"]:
                 #calling posthook with the block and output
                 output = posthook(bl, output)
         #final output
         return output
 
 
     def render_blocks(self, bls, collapse=False):
         '''This function renderes a list of blocks.
         It's the same as render_children_blocks but
         with a generic list'''
         output = []
         for bl in bls:
             output.append((bl.block_name,self.render_block(bl)))
         if collapse:
             return ''.join([x[1] for x in output])
         else:
             return output
diff --git a/texla/Renderers/plugins/math_check_online.py b/texla/Renderers/plugins/math_check_online.py
index b75cfbd..7b56fa0 100644
--- a/texla/Renderers/plugins/math_check_online.py
+++ b/texla/Renderers/plugins/math_check_online.py
@@ -1,110 +1,110 @@
 import requests
 import logging
 from multiprocessing import Process, Pool, Queue
 from os import path
 
 
 def request_formula(tex):
-    url_check = 'http://restbase.wikitolearn.org/pool.wikitolearn.org/v1/media/math/check/tex'
-#    url_check = 'http://restbase.tuttorotto.biz/pool.tuttorotto.biz/v1/media/math/check/tex'
+    url_check = 'http://restbase.{0}/pool.{0}/v1/media/math/check/tex'.format(configs["domain"])
     header = {
         'Accept': 'application/json',
         'Content-Type': 'application/x-www-form-urlencoded'
     }
     payload = {'q': tex}
     r = requests.post(url_check, data=payload, headers=header)
     if r.status_code == 200:
         return True
     else:
         return False
 
 
 formulas = []
 bad_formulas = Queue()
 
 
 def save_math(block):
     tex = block.attributes["content"]
     #saving the formula only if it's longer than 10
     if len(tex) > 5:
         logging.debug("Plugin math_check_online @ saving formula {}".format(
             tex))
         formulas.append((tex, block.id))
 
 
 def save_math_align(block):
     tex = "\\begin{align}" + block.attributes["content"] + "\\end{align}"
     #saving the formula only if it's longer than 10
     if len(tex) > 50:
         logging.debug("Plugin math_check_online @ saving formula {}".format(
             tex))
         formulas.append((tex, block.id))
 
 
 def check_math(formula):
     ok = request_formula(formula[0])
     if ok:
         logging.info("Plugin math_check_online @ formula {}, block_id: {}".
                      format("OK", formula[1]))
     else:
         logging.error("Plugin math_check_online @ formula {}, block_id: {}".
                       format("BAD", formula[1]))
         bad_formulas.put(formula)
 
 
 def start_pool():
-    pool = Pool(processes=6)
+    pool = Pool(processes=int(configs["threads"]))
     logging.info("Plugin math_check_online @ total formulas to check: {}".
                  format(len(formulas)))
     pool.map(check_math, formulas)
     #saving results
     logging.info("GOOD FORMULAS: {}  --- BAD FORMULAS: {}".format(
         len(formulas)-bad_formulas.qsize(), bad_formulas.qsize()))
     log_matherrors_file_path = path.relpath("sandbox/math_errors.txt")
     with open(log_matherrors_file_path, "w") as f:
         f.write("Math Errors Tree Log: \n")
         f.write("---------------------\n")
         ids = []
         while not bad_formulas.empty():
             form = bad_formulas.get()
             ids.append(form[1])
         output = tree_explorer.print_tree_to_blocks(ids)
         f.write(output + "\n\n")
 
 
 def start_check():
     p = Process(target=start_pool)
     p.start()
 
 
 plugin_render_hooks = {
     'displaymath': {
         "pre": save_math
     },
     'inlinemath': {
         "pre": save_math
     },
     'ensuremath': {
         "pre": save_math
     },
     'equation': {
         "pre": save_math
     },
     'eqnarray': {
         "pre": save_math_align
     },
     'multline': {
         "pre": save_math_align
     },
     'align': {
         "pre": save_math_align
     },
     'alignat': {
         "pre": save_math_align
     }
 }
 
 plugin_lifecycle_hooks = {"end": start_check}
 
 needs_tree_explorer = True
 tree_explorer = None
+configs = {}
diff --git a/texla/Reporter.py b/texla/Reporter.py
index 58ac3a0..1ea8609 100644
--- a/texla/Reporter.py
+++ b/texla/Reporter.py
@@ -1,40 +1,52 @@
 from .Parser.TreeExplorer import TreeExplorer
 import logging
 
 class Reporter:
 
     def __init__(self, tree):
         self.tree_explorer = tree
         #registering the block_names
         self.tree_explorer.register_block_names()
         self.not_parsed_blocks = self.tree_explorer.block_names["default"]
         self.not_rendered_blocks = []
         self.not_parsed_types = {}
         self.not_rendered_types = {}
         for bl in self.not_parsed_blocks:
             if bl.type not in self.not_parsed_types:
                 self.not_parsed_types[bl.type] = []
             self.not_parsed_types[bl.type].append(bl)
 
 
     def add_not_rendered_block(self, block):
         """This method saves a block that is not rendered by the Renderer."""
         self.not_rendered_blocks.append(block)
         if not block.block_name in self.not_rendered_types:
             self.not_rendered_types[block.block_name] = []
         self.not_rendered_types[block.block_name].append(block)
 
     def print_report(self, console=True):
         logging.info('\033[0;34m############### TEXLA REPORT  ###############\033[0m')
         s = []
         s.append("\n- NOT PARSED blocks:")
         for bl, v in self.not_parsed_types.items():
             s.append("\t- {} : {}".format(bl, len(v)))
         s.append("\n- NOT RENDERED blocks:")
         for bl, v in self.not_rendered_types.items():
             s.append("\t- {} : {}".format(bl, len(v)))
         text= "\n".join(s)
         if console:
             logging.info(text)
+        #saving to file also the block trees
         with open("sandbox/texla_report.txt",'w') as file:
-            file.write(text)
+            t = ["############### TEXLA REPORT  ###############"]
+            t.append("\n- NOT PARSED blocks:")
+            for bl, v in self.not_parsed_types.items():
+                t.append("\t- {} : {}".format(bl, len(v)))
+            t.append("\n- NOT PARSED blocks details:")
+            t.append(self.tree_explorer.print_tree_to_blocks(self.not_parsed_blocks))
+            t.append("\n- NOT RENDERED blocks:")
+            for bl, v in self.not_rendered_types.items():
+                t.append("\t- {} : {}".format(bl, len(v)))
+            t.append("\n- NOT RENDERED blocks details:")
+            t.append(self.tree_explorer.print_tree_to_blocks(self.not_rendered_blocks))
+            file.write("\n".join(t))