diff --git a/plugin.video.alfa/channels/goovie.json b/plugin.video.alfa/channels/goovie.json
new file mode 100644
index 00000000..1825251d
--- /dev/null
+++ b/plugin.video.alfa/channels/goovie.json
@@ -0,0 +1,79 @@
+{
+"id": "goovie",
+  "name": "Goovie",
+  "active": true,
+  "adult": false,
+  "language": ["cast", "lat"],
+  "thumbnail": "https://s15.postimg.cc/n9wp4nnzv/goovie.png",
+  "banner": "",
+  "categories": [
+    "movie",
+    "tvshow"
+  ],
+  "settings": [
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Incluir en busqueda global",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostrar enlaces en idioma...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "No filtrar",
+        "Latino",
+        "Castellano",
+        "VOSE",
+        "VO"
+      ]
+    },
+    {
+      "id": "include_in_newest_peliculas",
+      "type": "bool",
+      "label": "Incluir en Novedades - Peliculas",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_infantiles",
+      "type": "bool",
+      "label": "Incluir en Novedades - Infantiles",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_terror",
+      "type": "bool",
+      "label": "Incluir en Novedades - terror",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces",
+      "type": "bool",
+      "label": "Verificar si los enlaces existen",
+      "default": false,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces_num",
+      "type": "list",
+      "label": "Número de enlaces a verificar",
+      "default": 1,
+      "enabled": true,
+      "visible": "eq(-1,true)",
+      "lvalues": [ "5", "10", "15", "20" ]
+    }
+  ]
+}
diff --git a/plugin.video.alfa/channels/goovie.py b/plugin.video.alfa/channels/goovie.py
new file mode 100644
index 00000000..2948cf73
--- /dev/null
+++ b/plugin.video.alfa/channels/goovie.py
@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+# -*- Channel Goovie -*-
+# -*- Created for Alfa-addon -*-
+# -*- By the Alfa Develop Group -*-
+
+import re
+import urllib
+from channelselector import get_thumb
+from core import httptools
+from core import jsontools
+from core import scrapertools
+from core import servertools
+from core import tmdb
+from core.item import Item
+from channels import filtertools
+from channels import autoplay
+from platformcode import config, logger
+
+
+IDIOMAS = {'1':'Cast', '2':'Lat', '3':'VOSE', '4':'VO'}
+list_language = IDIOMAS.values()
+
+CALIDADES = {'1':'1080','2':'720','3':'480','4':'360'}
+
+list_quality = ['1080', '720', '480', '360']
+
+list_servers = [
+    'powvideo'
+]
+
+__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', 'goovie')
+__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', 'goovie')
+
+host = 'https://goovie.co/'
+
+def mainlist(item):
+    logger.info()
+
+    autoplay.init(item.channel, list_servers, list_quality)
+
+    itemlist = []
+
+    itemlist.append(Item(channel=item.channel, title='Peliculas', action='sub_menu', type='peliculas',
+                         thumbnail= get_thumb('movies', auto=True)))
+    itemlist.append(Item(channel=item.channel, title='Series', action='sub_menu', type='series',
+                         thumbnail= get_thumb('tvshows', auto=True)))
+    itemlist.append(
+        item.clone(title="Buscar", action="search", url=host + 'search?go=', thumbnail=get_thumb("search", auto=True),
+                   extra='movie'))
+
+    autoplay.show_option(item.channel, itemlist)
+
+    return itemlist
+
+def sub_menu(item):
+    logger.info()
+
+    itemlist=[]
+
+    itemlist.append(Item(channel=item.channel, title='Todas', url=host + item.type, action='list_all',
+                         thumbnail=get_thumb('all', auto=True), type=item.type))
+    itemlist.append(Item(channel=item.channel, title='Genero', action='section',
+                         thumbnail=get_thumb('genres', auto=True), type=item.type))
+    itemlist.append(Item(channel=item.channel, title='Por Año', action='section',
+                         thumbnail=get_thumb('year', auto=True), type=item.type))
+
+    return itemlist
+
+def get_source(url):
+    logger.info()
+    data = httptools.downloadpage(url).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    return data
+
+
+def get_language(lang_data):
+    logger.info()
+    language = []
+
+    lang_list = scrapertools.find_multiple_matches(lang_data, '/flags/(.*?).png\)')
+    for lang in lang_list:
+        if lang == 'en':
+            lang = 'vose'
+        if lang not in language:
+            language.append(lang)
+    return language
+
+def section(item):
+    logger.info()
+    itemlist=[]
+    data = get_source(host+item.type)
+
+    if 'Genero' in item.title:
+        data = scrapertools.find_single_match(data, 'genero.*?</ul>')
+    elif 'Año' in item.title:
+        data = scrapertools.find_single_match(data, 'año.*?</ul>')
+    patron = '<a href=(.*?) >(.*?)</a>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedtitle in matches:
+        title = scrapedtitle
+        itemlist.append(Item(channel=item.channel, url=scrapedurl, title=title, action='list_all',
+                                 type=item.type))
+    return itemlist
+
+
+def list_all(item):
+    logger.info()
+    itemlist = []
+
+    data = get_source(item.url)
+    #logger.debug(data)
+    #return
+    if item.type ==  'peliculas':
+        patron = '<article class=Items>.*?<img src=(.*?) />.*?<a href=(.*?)><h2>(.*?)</h2>.*?'
+        patron += "<p>(.*?)</p><span>(\d{4}) /.*?</span>.*?'(\d+)'"
+        matches = re.compile(patron, re.DOTALL).findall(data)
+
+        for scrapedthumbnail, scrapedurl, scrapedtitle, scrapedplot, year, video_id in matches:
+
+            title = '%s [%s]' % (scrapedtitle, year)
+            contentTitle = scrapedtitle
+            thumbnail = scrapedthumbnail
+            url = scrapedurl
+
+            itemlist.append(item.clone(action='findvideos',
+                            title=title,
+                            url=url,
+                            thumbnail=thumbnail,
+                            contentTitle=contentTitle,
+                            video_id=video_id,
+                            infoLabels={'year':year}))
+
+    elif item.type ==  'series':
+        patron = '<article class=GoItemEp>.*?<a href=(.*?)>.*?<img src=(.*?) />.*?'
+        patron +='<h2>(.*?)</h2><p>(.*?)</p><span>(\d{4}) /'
+        matches = re.compile(patron, re.DOTALL).findall(data)
+
+        for scrapedurl, scrapedthumbnail, scrapedtitle, scrapedplot, year in matches:
+            title = scrapedtitle
+            contentSerieName = scrapedtitle
+            thumbnail = scrapedthumbnail
+            url = scrapedurl
+
+            itemlist.append(item.clone(action='seasons',
+                            title=title,
+                            url=url,
+                            thumbnail=thumbnail,
+                            plot=scrapedplot,
+                            contentSerieName=contentSerieName,
+                            infoLabels={'year':year}))
+
+    tmdb.set_infoLabels(itemlist, seekTmdb=True)
+    #  Paginación
+
+    url_next_page = scrapertools.find_single_match(data,"<link rel=next href=(.*?) />")
+    if url_next_page:
+        itemlist.append(item.clone(title="Siguiente >>", url=url_next_page, action='list_all'))
+
+    return itemlist
+
+def seasons(item):
+    logger.info()
+
+    itemlist=[]
+
+    data=get_source(item.url)
+    patron='<div class=season temporada-(\d+)>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    infoLabels = item.infoLabels
+    for season in matches:
+        season = season.lower().replace('temporada','')
+        infoLabels['season']=season
+        title = 'Temporada %s' % season
+        itemlist.append(Item(channel=item.channel, title=title, url=item.url, action='episodesxseasons',
+                             infoLabels=infoLabels))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    if config.get_videolibrary_support() and len(itemlist) > 0:
+        itemlist.append(
+                Item(channel=item.channel, title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]', url=item.url,
+                     action="add_serie_to_library", extra="episodios", contentSerieName=item.contentSerieName))
+
+    return itemlist
+
+def episodios(item):
+    logger.info()
+    itemlist = []
+    templist = seasons(item)
+    for tempitem in templist:
+        itemlist += episodesxseasons(tempitem)
+
+    return itemlist
+
+def episodesxseasons(item):
+    logger.info()
+
+    itemlist = []
+
+    data=get_source(item.url)
+    logger.debug(data)
+    patron= "ViewEpisode\('(\d+)', this\)><div class=num>%s - (\d+)</div>" % item.infoLabels['season']
+    patron += ".*?src=(.*?) />.*?namep>(.*?)<span>"
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    infoLabels = item.infoLabels
+
+    for video_id, scrapedepisode, scrapedthumbnail, scrapedtitle in matches:
+
+        infoLabels['episode'] = scrapedepisode
+        title = '%sx%s - %s' % (infoLabels['season'], infoLabels['episode'], scrapedtitle)
+
+        itemlist.append(Item(channel=item.channel, title= title, url=item.url, thumbnail=scrapedthumbnail,
+                             action='findvideos', video_id=video_id, infoLabels=infoLabels))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+
+def findvideos(item):
+    logger.info()
+    from lib import jsunpack
+    itemlist = []
+    headers = {'referer':item.url}
+    if item.video_id == '':
+        find_id = get_source(item.url)
+        #logger.debug(find_id)
+        #return
+        item.video_id = scrapertools.find_single_match(find_id, 'var centerClick = (\d+);')
+    url = 'https://goovie.co/api/links/%s' % item.video_id
+    data = httptools.downloadpage(url, headers=headers).data
+    video_list = jsontools.load(data)
+    for video_info in video_list:
+        logger.debug(video_info)
+        url = video_info['visor']
+        plot = 'idioma: %s calidad: %s' % (video_info['idioma'], video_info['calidad'])
+        data = httptools.downloadpage(url, headers=headers, follow_redirects=False).data
+        data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+        packed = scrapertools.find_single_match(data, '(eval\(.*?);var')
+        unpacked = jsunpack.unpack(packed)
+        logger.debug('unpacked %s' % unpacked)
+        server = scrapertools.find_single_match(unpacked, "src:.'(http://\D+)/")
+        id = scrapertools.find_single_match(unpacked, "src:.'http://\D+/.*?description:.'(.*?).'")
+        if server == '':
+            if 'powvideo' in unpacked:
+                id = scrapertools.find_single_match(unpacked ,",description:.'(.*?).'")
+                server= 'https://powvideo.net'
+        url = '%s/%s' % (server, id)
+        if server != '' and id != '':
+            language = IDIOMAS[video_info['idioma']]
+            quality = CALIDADES[video_info['calidad']]
+            title = ' [%s] [%s]' % (language, quality)
+            itemlist.append(Item(channel=item.channel, title='%s'+title, url=url, action='play', language=language,
+                                 quality=quality))
+
+    itmelist = servertools.get_servers_itemlist(itemlist, lambda i: i.title % i.server.capitalize())
+    return sorted(itemlist, key=lambda i: i.language)
+
+
+def search(item, texto):
+    logger.info()
+    texto = texto.replace(" ", "+")
+    item.url = item.url + texto
+    item.type = 'peliculas'
+    if texto != '':
+        return search_results(item)
+    else:
+        return []
+
+def search_results(item):
+    logger.info()
+
+    itemlist=[]
+
+    data=get_source(item.url)
+    logger.debug(data)
+    patron = '<article class=Items>.*?href=(.*?)>.*?typeContent>(.*?)<.*?'
+    patron += '<img src=(.*?) />.*?<h2>(.*?)</h2><p>(.*?)</p><span>(\d{4})<'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, content_type ,scrapedthumb, scrapedtitle, scrapedplot, year in matches:
+
+        title = scrapedtitle
+        url = scrapedurl
+        thumbnail = scrapedthumb
+        plot = scrapedplot
+        if content_type != 'Serie':
+            action = 'findvideos'
+        else:
+            action = 'seasons'
+
+        new_item=Item(channel=item.channel, title=title, url=url, thumbnail=thumbnail, plot=plot,
+                             action=action, type=content_type, infoLabels={'year':year})
+        if new_item.action == 'findvideos':
+            new_item.contentTitle = new_item.title
+        else:
+            new_item.contentSerieName = new_item.title
+
+        itemlist.append(new_item)
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+def newest(categoria):
+    logger.info()
+    itemlist = []
+    item = Item()
+    try:
+        if categoria in ['peliculas']:
+            item.url = host + 'peliculas'
+        elif categoria == 'infantiles':
+            item.url = host + 'peliculas/generos/animación'
+        elif categoria == 'terror':
+            item.url = host + 'peliculas/generos/terror'
+        item.type='peliculas'
+        itemlist = list_all(item)
+        if itemlist[-1].title == 'Siguiente >>':
+            itemlist.pop()
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
diff --git a/plugin.video.alfa/channels/pelisr.json b/plugin.video.alfa/channels/pelisr.json
new file mode 100644
index 00000000..92257e9e
--- /dev/null
+++ b/plugin.video.alfa/channels/pelisr.json
@@ -0,0 +1,79 @@
+{
+"id": "pelisr",
+  "name": "PelisR",
+  "active": true,
+  "adult": false,
+  "language": ["lat", "cast", "vose"],
+  "thumbnail": "https://s22.postimg.cc/gcp2jqbs1/pelisr.png",
+  "banner": "",
+  "categories": [
+    "movie",
+    "tvshow",
+    "direct"
+  ],
+  "settings": [
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Incluir en busqueda global",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostrar enlaces en idioma...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "No filtrar",
+        "Latino",
+        "Castellano",
+        "VOSE"
+      ]
+    },
+    {
+      "id": "include_in_newest_peliculas",
+      "type": "bool",
+      "label": "Incluir en Novedades - Peliculas",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_infantiles",
+      "type": "bool",
+      "label": "Incluir en Novedades - Infantiles",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_terror",
+      "type": "bool",
+      "label": "Incluir en Novedades - terror",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces",
+      "type": "bool",
+      "label": "Verificar si los enlaces existen",
+      "default": false,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces_num",
+      "type": "list",
+      "label": "Número de enlaces a verificar",
+      "default": 1,
+      "enabled": true,
+      "visible": "eq(-1,true)",
+      "lvalues": [ "5", "10", "15", "20" ]
+    }
+  ]
+}
diff --git a/plugin.video.alfa/channels/pelisr.py b/plugin.video.alfa/channels/pelisr.py
new file mode 100644
index 00000000..7d826449
--- /dev/null
+++ b/plugin.video.alfa/channels/pelisr.py
@@ -0,0 +1,366 @@
+# -*- coding: utf-8 -*-
+# -*- Channel PoseidonHD -*-
+# -*- Created for Alfa-addon -*-
+# -*- By the Alfa Develop Group -*-
+
+import re
+import urllib
+import base64
+
+from channelselector import get_thumb
+from core import httptools
+from core import jsontools
+from core import scrapertools
+from core import servertools
+from core import tmdb
+from lib import jsunpack
+from core.item import Item
+from channels import filtertools
+from channels import autoplay
+from platformcode import config, logger
+
+
+IDIOMAS = {'mx': 'Latino', 'dk':'Latino', 'es': 'Castellano', 'en': 'VOSE', 'gb':'VOSE'}
+list_language = IDIOMAS.values()
+
+list_quality = ['360P', '480P', '720P', '1080P']
+
+list_servers = [
+    'directo',
+    'openload',
+    'rapidvideo'
+]
+
+__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', 'poseidonhd')
+__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', 'poseidonhd')
+
+host = 'https://pelisr.com/'
+
+def mainlist(item):
+    logger.info()
+
+    autoplay.init(item.channel, list_servers, list_quality)
+
+    itemlist = []
+
+    itemlist.append(Item(channel=item.channel, title='Peliculas', action='menu_movies',
+                         thumbnail= get_thumb('movies', auto=True)))
+    itemlist.append(Item(channel=item.channel, title='Series', url=host+'tvshows', action='list_all', type='tvshows',
+                         thumbnail= get_thumb('tvshows', auto=True)))
+    itemlist.append(
+        item.clone(title="Buscar", action="search", url=host + '?s=', thumbnail=get_thumb("search", auto=True),
+                   extra='movie'))
+
+    autoplay.show_option(item.channel, itemlist)
+
+    return itemlist
+
+def menu_movies(item):
+    logger.info()
+
+    itemlist=[]
+
+    itemlist.append(Item(channel=item.channel, title='Todas', url=host + 'movies', action='list_all',
+                         thumbnail=get_thumb('all', auto=True), type='movies'))
+    itemlist.append(Item(channel=item.channel, title='Genero', action='section',
+                         thumbnail=get_thumb('genres', auto=True), type='movies'))
+    itemlist.append(Item(channel=item.channel, title='Por Año', action='section',
+                         thumbnail=get_thumb('year', auto=True), type='movies'))
+
+    return itemlist
+
+def get_source(url):
+    logger.info()
+    data = httptools.downloadpage(url).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    return data
+
+
+def get_language(lang_data):
+    logger.info()
+    language = []
+    logger.debug(lang_data)
+    lang_list = scrapertools.find_multiple_matches(lang_data, '/flags/(.*?).png\)')
+    for lang in lang_list:
+        if lang == 'en':
+            lang = 'vose'
+        if lang not in language:
+            language.append(lang)
+    return language
+
+def section(item):
+    logger.info()
+    itemlist=[]
+    duplicados=[]
+    data = get_source(host+'/'+item.type)
+    if 'Genero' in item.title:
+        patron = '<li class=cat-item cat-item-\d+><a href=(.*?) >(.*?)/i>'
+    elif 'Año' in item.title:
+        patron = '<li><a href=(.*?release.*?)>(.*?)</a>'
+    elif 'Calidad' in item.title:
+        patron = 'menu-item-object-dtquality menu-item-\d+><a href=(.*?)>(.*?)</a>'
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedtitle in matches:
+        title = scrapedtitle
+        plot=''
+        if 'Genero' in item.title:
+            quantity =  scrapertools.find_single_match(scrapedtitle,'</a> <i>(.*?)<')
+            title = scrapertools.find_single_match(scrapedtitle,'(.*?)</')
+            title = title
+            plot = '%s elementos' % quantity.replace('.','')
+        else:
+            title = scrapedtitle
+        if title not in duplicados:
+            itemlist.append(Item(channel=item.channel, url=scrapedurl, title=title, plot=plot, action='list_all',
+                                 type=item.type))
+            duplicados.append(title)
+
+    return itemlist
+
+
+def list_all(item):
+    logger.info()
+    itemlist = []
+
+    data = get_source(item.url)
+    logger.debug(data)
+    #return
+
+    if item.type ==  'movies':
+        patron = '<article id=post-\d+ class=item movies><div class=poster><img src=(.*?) alt=(.*?)>.*?quality>(.*?)'
+        patron += '</span><\/div><a href=(.*?)>.*?<\/h3><span>(.*?)<\/span><\/div>.*?flags(.*?)metadata'
+        matches = re.compile(patron, re.DOTALL).findall(data)
+
+        for scrapedthumbnail, scrapedtitle, quality, scrapedurl, year, lang_data in matches:
+
+
+            title = '%s [%s] [%s]' % (scrapedtitle, year, quality)
+            contentTitle = scrapedtitle
+            thumbnail = scrapedthumbnail
+            url = scrapedurl
+            language = get_language(lang_data)
+
+            itemlist.append(item.clone(action='findvideos',
+                            title=title,
+                            url=url,
+                            thumbnail=thumbnail,
+                            contentTitle=contentTitle,
+                            language=language,
+                            quality=quality,
+                            infoLabels={'year':year}))
+
+    elif item.type ==  'tvshows':
+        patron = '<article id=post-\d+ class=item tvshows><div class=poster><img src=(.*?) alt=(.*?)>.*?'
+        patron += '<a href=(.*?)>.*?<\/h3><span>(.*?)<\/span><\/div>'
+        matches = re.compile(patron, re.DOTALL).findall(data)
+
+        for scrapedthumbnail, scrapedtitle, scrapedurl, year in matches:
+            title = scrapedtitle
+            contentSerieName = scrapedtitle
+            thumbnail = scrapedthumbnail
+            url = scrapedurl
+
+            itemlist.append(item.clone(action='seasons',
+                            title=title,
+                            url=url,
+                            thumbnail=thumbnail,
+                            contentSerieName=contentSerieName,
+                            infoLabels={'year':year}))
+
+    tmdb.set_infoLabels(itemlist, seekTmdb=True)
+    #  Paginación
+
+    #url_next_page = scrapertools.find_single_match(data,"<a class='arrow_pag' href=([^>]+)><i id='nextpagination'")
+    url_next_page = scrapertools.find_single_match(data,"<link rel=next href=([^ ]+) />")
+    if url_next_page:
+        itemlist.append(item.clone(title="Siguiente >>", url=url_next_page, action='list_all'))
+
+    return itemlist
+
+def seasons(item):
+    logger.info()
+
+    itemlist=[]
+
+    data=get_source(item.url)
+    logger.debug(data)
+    patron='Temporada \d+'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    infoLabels = item.infoLabels
+    for season in matches:
+        season = season.lower().replace('temporada','')
+        infoLabels['season']=season
+        title = 'Temporada %s' % season
+        itemlist.append(Item(channel=item.channel, title=title, url=item.url, action='episodesxseasons',
+                             infoLabels=infoLabels))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    if config.get_videolibrary_support() and len(itemlist) > 0:
+        itemlist.append(
+                Item(channel=item.channel, title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]', url=item.url,
+                     action="add_serie_to_library", extra="episodios", contentSerieName=item.contentSerieName))
+
+    return itemlist
+
+def episodios(item):
+    logger.info()
+    itemlist = []
+    templist = seasons(item)
+    for tempitem in templist:
+        itemlist += episodesxseasons(tempitem)
+
+    return itemlist
+
+def episodesxseasons(item):
+    logger.info()
+
+    itemlist = []
+
+    data=get_source(item.url)
+    patron='class=numerando>%s - (\d+)</div><div class=episodiotitle><a href=(.*?)>(.*?)<' % item.infoLabels['season']
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    infoLabels = item.infoLabels
+
+    for scrapedepisode, scrapedurl, scrapedtitle in matches:
+
+        infoLabels['episode'] = scrapedepisode
+        url = scrapedurl
+        title = '%sx%s - %s' % (infoLabels['season'], infoLabels['episode'], scrapedtitle)
+
+        itemlist.append(Item(channel=item.channel, title= title, url=url, action='findvideos', infoLabels=infoLabels))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+
+def findvideos(item):
+    logger.info()
+    from lib import generictools
+    itemlist = []
+    data = get_source(item.url)
+    logger.debug(data)
+    patron = 'id=option-(\d+).*?rptss src=(.*?) frameborder'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    for option, scrapedurl in matches:
+        logger.debug(scrapedurl)
+        lang = scrapertools.find_single_match(data, 'href=#option-%s>.*?/flags/(.*?).png' % option)
+        quality = ''
+        if lang not in IDIOMAS:
+            lang = 'en'
+        title = '%s'
+
+        if 'embed' in scrapedurl:
+            enc_data = get_source(scrapedurl)
+            dec_data = generictools.dejuice(enc_data)
+            url, quality = scrapertools.find_single_match(dec_data, '"file":"(.*?)","label":"(.*?)"')
+
+        elif 'wd=' in scrapedurl:
+            new_id = scrapertools.find_single_match(scrapedurl, 'wd=(.*?)&')
+            logger.debug('new_id %s' % new_id)
+            new_id = new_id[::-1]
+            new_url = 'https://pelisr.com/encri/?wr=%s' % new_id
+            headers = {'Referer': scrapedurl}
+            data = httptools.downloadpage(new_url, headers=headers, follow_redirects=False)
+            url = data.headers['location']
+
+        itemlist.append(
+            Item(channel=item.channel, url=url, title=title, action='play', quality=quality, language=IDIOMAS[lang],
+                 infoLabels=item.infoLabels))
+
+    itemlist = servertools.get_servers_itemlist(itemlist, lambda x: x.title % x.server.capitalize())
+
+    # Requerido para Filtrar enlaces
+
+    if __comprueba_enlaces__:
+        itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
+
+    # Requerido para FilterTools
+
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    # Requerido para AutoPlay
+
+    autoplay.start(itemlist, item)
+
+    itemlist = sorted(itemlist, key=lambda it: it.language)
+
+    if item.contentType != 'episode':
+        if config.get_videolibrary_support() and len(itemlist) > 0 and item.extra != 'findvideos':
+            itemlist.append(
+                Item(channel=item.channel, title='[COLOR yellow]Añadir esta pelicula a la videoteca[/COLOR]', url=item.url,
+                     action="add_pelicula_to_library", extra="findvideos", contentTitle=item.contentTitle))
+
+    return itemlist
+
+def search(item, texto):
+    logger.info()
+    texto = texto.replace(" ", "+")
+    item.url = item.url + texto
+
+    if texto != '':
+        return search_results(item)
+    else:
+        return []
+
+def search_results(item):
+    logger.info()
+
+    itemlist=[]
+
+    data=get_source(item.url)
+    patron = '<article>.*?<a href=(.*?)><img src=(.*?) alt=(.*?) />.*?meta.*?year>(.*?)<(.*?)<p>(.*?)</p>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedthumb, scrapedtitle, year, lang_data, scrapedplot in matches:
+
+        title = scrapedtitle
+        url = scrapedurl
+        thumbnail = scrapedthumb
+        plot = scrapedplot
+        language = get_language(lang_data)
+        if language:
+            action = 'findvideos'
+        else:
+            action = 'seasons'
+
+        new_item=Item(channel=item.channel, title=title, url=url, thumbnail=thumbnail, plot=plot,
+                             action=action,
+                             language=language, infoLabels={'year':year})
+        if new_item.action == 'findvideos':
+            new_item.contentTitle = new_item.title
+        else:
+            new_item.contentSerieName = new_item.title
+
+        itemlist.append(new_item)
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+def newest(categoria):
+    logger.info()
+    itemlist = []
+    item = Item()
+    try:
+        if categoria in ['peliculas']:
+            item.url = host + 'movies/'
+        elif categoria == 'infantiles':
+            item.url = host + 'genre/animacion/'
+        elif categoria == 'terror':
+            item.url = host + 'genre/terror/'
+        item.type='movies'
+        itemlist = list_all(item)
+        if itemlist[-1].title == 'Siguiente >>':
+            itemlist.pop()
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
diff --git a/plugin.video.alfa/channels/retroseriestv.json b/plugin.video.alfa/channels/retroseriestv.json
new file mode 100644
index 00000000..cde2358b
--- /dev/null
+++ b/plugin.video.alfa/channels/retroseriestv.json
@@ -0,0 +1,22 @@
+{
+  "id": "retroseriestv",
+  "name": "RetroSeriesTV",
+  "active": true,
+  "adult": false,
+  "language": ["lat", "cast"],
+  "thumbnail": "https://retroseriestv.com/wp-content/uploads/2017/04/Logo3-5.png",
+  "banner": "",
+  "categories": [
+    "tvshow"
+  ],
+  "settings": [
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Incluir en busqueda global",
+      "default": false,
+      "enabled": false,
+      "visible": false
+    }
+  ]
+}
\ No newline at end of file
diff --git a/plugin.video.alfa/channels/retroseriestv.py b/plugin.video.alfa/channels/retroseriestv.py
new file mode 100644
index 00000000..2386b82f
--- /dev/null
+++ b/plugin.video.alfa/channels/retroseriestv.py
@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+# -*- Channel RetroSeriesTV -*-
+# -*- Created for Alfa-addon -*-
+# -*- By the Alfa Develop Group -*-
+
+import re
+import urllib
+from channelselector import get_thumb
+from core import httptools
+from core import scrapertools
+from core import servertools
+from core import tmdb
+from core.item import Item
+from platformcode import config, logger
+from channels import autoplay
+from channels import filtertools
+
+
+host = 'https://retroseriestv.com/'
+
+# IDIOMAS = {'la': 'LAT', 'es': 'Cast'}
+# list_language = IDIOMAS.values()
+# list_quality = []
+# list_servers = ['openload']
+
+
+def mainlist(item):
+    logger.info()
+
+    itemlist = list()
+    itemlist.append(item.clone(title="Todas", action="list_all", url=host + 'seriestv/', thumbnail=get_thumb('all',
+                                                                                                         auto=True)))
+
+    itemlist.append(item.clone(title="Generos", action="section", url=host, thumbnail=get_thumb('genres', auto=True),
+                               section='genres'))
+
+    itemlist.append(item.clone(title="Por Año", action="section", url=host, thumbnail=get_thumb('year', auto=True),
+                               section='year'))
+
+    itemlist.append(item.clone(title="Alfabetico", action="section", url=host, thumbnail=get_thumb('alphabet', auto=True),
+                               section='abc'))
+
+    itemlist.append(item.clone(title="Buscar", action="search", url=host+'?s=',
+                               thumbnail=get_thumb('search', auto=True)))
+
+    return itemlist
+
+
+def get_source(url):
+    logger.info()
+    data = httptools.downloadpage(url).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    return data
+
+def list_all(item):
+    logger.info()
+    itemlist = []
+
+    data = get_source(item.url)
+    patron = '<article id=post-.*?<a href=(.*?)><img src=(.*?) alt=(.*?)><.*?<span>(.*?)<'
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedthumbnail, scrapedtitle, year in matches:
+
+        url = scrapedurl
+        contentSerieName = scrapedtitle
+        thumbnail = scrapedthumbnail
+        itemlist.append(item.clone(action='seasons',
+                                   title=contentSerieName,
+                                   url=url,
+                                   thumbnail=thumbnail,
+                                   contentSerieName=contentSerieName,
+                                   infoLabels={'year':year}
+                                   ))
+    tmdb.set_infoLabels_itemlist(itemlist, True)
+
+    #  Paginación
+
+    url_next_page = scrapertools.find_single_match(data,'rel=next.*?href=(.*?) ')
+    if url_next_page:
+        itemlist.append(item.clone(title="Siguiente >>", url=url_next_page, action='list_all'))
+    return itemlist
+
+def section(item):
+    logger.info()
+
+    itemlist = []
+
+    data = get_source(item.url)
+    data = scrapertools.find_single_match(data, '<ul class=%s(.*?)</ul>' % item.section)
+    patron = '<a href=(.*?)>(.*?)</a>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedtitle in matches:
+        url = scrapedurl.strip()
+        itemlist.append(Item(channel=item.channel, title=scrapedtitle, url=url, action='list_all'))
+
+    return itemlist
+
+def seasons(item):
+    logger.info()
+
+    itemlist = []
+    data = get_source(item.url)
+    patron = '<span class=title>Temporada(\d+) <'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedtitle in matches:
+        infoLabels = item.infoLabels
+        infoLabels['season'] = scrapedtitle
+        title = 'Temporada %s' % scrapedtitle
+        itemlist.append(Item(channel=item.channel, title=title, url=item.url, action='episodesxseason',
+                             infoLabels=infoLabels))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    if config.get_videolibrary_support() and len(itemlist) > 0:
+        itemlist.append(
+            Item(channel=item.channel, title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]', url=item.url,
+                 action="add_serie_to_library", extra="episodios", contentSerieName=item.contentSerieName,
+                 extra1='library'))
+
+    return itemlist
+
+def episodios(item):
+    logger.info()
+    itemlist = []
+    templist = seasons(item)
+    for tempitem in templist:
+        itemlist += episodesxseason(tempitem)
+    return itemlist
+
+def episodesxseason(item):
+    logger.info()
+
+    itemlist = []
+
+    data = get_source(item.url)
+    infoLabels = item.infoLabels
+    season = infoLabels['season']
+    patron = '<img src=([^>]+)></a></div><div class=numerando>%s - (\d+)</div>' % season
+    patron += '<div class=episodiotitle><a href=(.*?)>(.*?)</a><'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedthumbnail, scrapedepi, scrapedurl, scrapedtitle in matches:
+
+        title = '%sx%s - %s' % (season, scrapedepi, scrapedtitle)
+        infoLabels['episode'] = scrapedepi
+        if scrapedepi > 0:
+            itemlist.append(Item(channel=item.channel, title=title, url=scrapedurl, action='findvideos',
+                            infoLabels=infoLabels))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+def findvideos(item):
+    logger.info()
+
+    itemlist = []
+
+    data = get_source(item.url)
+    patron = 'id=([^ ]+) class=play-box-iframe .*?src=(.*?) frameborder=0.*?'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for option, scrapedurl in matches:
+        #language = scrapertools.find_single_match(data, '#%s.*?dt_flag><img src=.*?flags/(.*?).png' % option)
+        #title = '%s [%s]'
+        language = ''
+        title = '%s'
+        SerieName = item.contentSerieName
+        itemlist.append(Item(channel=item.channel, title=title, contentSerieName=SerieName, url=scrapedurl,
+                             action='play', language=language, infoLabels=item.infoLabels))
+
+    #itemlist = servertools.get_servers_itemlist(itemlist, lambda i: i.title % (i.server.capitalize(), i.language))
+    itemlist = servertools.get_servers_itemlist(itemlist, lambda i: i.title % i.server.capitalize())
+    return itemlist
+
+def search_results(item):
+    logger.info()
+
+    itemlist = []
+
+    data = get_source(item.url)
+    patron = '<article.*?<a href=(.*?)><img src=(.*?) alt=(.*?)><.*?year>(.*?)<.*?<p>(.*?)</p>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedthumbnail, scrapedtitle, year, scrapedplot in matches:
+
+        url = scrapedurl
+        contentSerieName = scrapedtitle.replace(' /','')
+        thumbnail = scrapedthumbnail
+        itemlist.append(item.clone(action='seasons',
+                                   title=contentSerieName,
+                                   url=url,
+                                   thumbnail=thumbnail,
+                                   plot=scrapedplot,
+                                   contentSerieName=contentSerieName,
+                                   infoLabels={'year':year}
+                                   ))
+    tmdb.set_infoLabels_itemlist(itemlist, True)
+
+    return itemlist
+
+def search(item, texto):
+    logger.info()
+    texto = texto.replace(" ", "+")
+    item.url = item.url + texto
+
+    if texto != '':
+        return search_results(item)
+    else:
+        return []
diff --git a/plugin.video.alfa/channels/search.py b/plugin.video.alfa/channels/search.py
index 3a9332cd..1452bbd6 100644
--- a/plugin.video.alfa/channels/search.py
+++ b/plugin.video.alfa/channels/search.py
@@ -8,15 +8,79 @@ from threading import Thread
 
 from channelselector import get_thumb
 from core import channeltools
+from core import scrapertools
 from core.item import Item
 from platformcode import config, logger
 from platformcode import platformtools
+from core import tmdb
+
+link_list = []
+max_links = 30
 
 
 def mainlist(item):
     logger.info()
     item.channel = "search"
 
+    itemlist = []
+    context = [{"title": "Elegir canales incluidos", "action": "setting_channel", "channel": item.channel}]
+    itemlist.append(Item(channel=item.channel, action="sub_menu", title="Buscar en canales", context=context,
+                         thumbnail=get_thumb("search.png")))
+
+    itemlist.append(Item(channel=item.channel, action='genres_menu', title='Películas por Generos', type='movie',
+                         thumbnail=get_thumb("genres.png")))
+
+    itemlist.append (Item(channel=item.channel, action='discover_list', title='Películas mas populares',
+                          context=context, search_type='list', list_type='movie/popular',
+                          thumbnail=get_thumb("popular.png")))
+
+    itemlist.append(Item(channel=item.channel, action='discover_list', title='Películas mejor valoradas',
+                         context=context, search_type='list', list_type='movie/top_rated',
+                         thumbnail=get_thumb("top_rated.png")))
+
+    itemlist.append(
+        Item(channel=item.channel, action='discover_list', title='Películas Ahora en cines', context=context,
+             search_type='list', list_type='movie/now_playing',
+                         thumbnail=get_thumb("now_playing.png")))
+
+    itemlist.append(Item(channel=item.channel, action='genres_menu', title='Series por Generos', type='tv',
+                         thumbnail=get_thumb("genres.png")))
+
+    itemlist.append(
+        Item(channel=item.channel, action='discover_list', title='Series mas populares', context=context,
+             search_type='list',list_type='tv/popular', thumbnail=get_thumb("popular.png")))
+
+    itemlist.append(Item(channel=item.channel, action='discover_list', title='Series en emisión', context=context,
+                         search_type='list', list_type='tv/on_the_air', thumbnail=get_thumb("on_the_air.png")))
+
+
+    itemlist.append(Item(channel=item.channel, action='discover_list', title='Series mejor valoradas', context=context,
+                         search_type='list', list_type='tv/top_rated', thumbnail=get_thumb("top_rated.png")))
+
+
+
+
+    return itemlist
+
+
+def genres_menu(item):
+
+    itemlist = []
+
+    genres = tmdb.get_genres(item.type)
+
+    logger.debug(genres)
+    logger.debug(genres[item.type])
+
+    for key, value in genres[item.type].items():
+        itemlist.append(item.clone(title=value, action='discover_list', search_type='discover',
+                                   list_type=key, page='1'))
+    return sorted(itemlist, key=lambda it: it.title)
+
+def sub_menu(item):
+    logger.info()
+    item.channel = "search"
+
     itemlist = list()
     context = [{"title": config.get_localized_string(70273),
                 "action": "setting_channel",
@@ -436,7 +500,7 @@ def do_search(item, categories=None):
             title = channel
 
             # resultados agrupados por canales
-            if item.contextual == True:
+            if item.contextual == True or item.action == 'search_tmdb':
                 result_mode = 1
             if result_mode == 0:
                 if len(search_results[channel]) > 1:
@@ -517,3 +581,90 @@ def get_saved_searches():
         saved_searches_list = list(current_saved_searches_list)
 
     return saved_searches_list
+
+
+def discover_list(item):
+    from platformcode import unify
+    itemlist = []
+
+    result = tmdb.discovery(item)
+
+    tvshow = False
+
+    logger.debug(item)
+
+    for elem in result:
+        elem['tmdb_id']=elem['id']
+        if 'title' in elem:
+            title = unify.normalize(elem['title']).capitalize()
+            elem['year'] = scrapertools.find_single_match(elem['release_date'], '(\d{4})-\d+-\d+')
+        else:
+            title = unify.normalize(elem['name']).capitalize()
+            tvshow = True
+
+        new_item = Item(channel='search', title=title, infoLabels=elem, action='search_tmdb', extra=title,
+                        category='Resultados', context ='')
+
+        if tvshow:
+            new_item.contentSerieName = title
+        else:
+            new_item.contentTitle = title
+
+        itemlist.append(new_item)
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    if item.page != '' and len(itemlist)>0:
+        next_page = str(int(item.page)+1)
+        #if not 'similar' in item.list_type:
+        #    itemlist.append(item.clone(title='Pagina Siguente', page=next_page))
+        #else:
+        itemlist.append(Item(channel=item.channel, action='discover_list', title='Pagina Siguente',
+                             search_type=item.search_type, list_type=item.list_type, type=item.type, page=next_page))
+
+    return itemlist
+
+def search_tmdb(item):
+    logger.debug(item)
+
+    itemlist = []
+    threads = []
+    logger.debug(item)
+    wanted = item.contentTitle
+
+    search = do_search(item)
+
+    if item.contentSerieName == '':
+        results = exact_results(search, wanted)
+        for result in results:
+            logger.debug(result)
+            t = Thread(target=get_links, args=[result])
+            t.start()
+            threads.append(t)
+
+            for thread in threads:
+                thread.join()
+
+            # try:
+            #     get_links(result)
+            # except:
+            #     pass
+
+        for link in link_list:
+            if link.action == 'play' and not 'trailer' in link.title.lower() and len(itemlist) < max_links:
+                itemlist.append(link)
+
+        return sorted(itemlist, key=lambda it: it.server)
+    else:
+        for item in search:
+            if item.contentSerieName != '' and item.contentSerieName == wanted:
+                logger.debug(item)
+                itemlist.append(item)
+        return itemlist
+
+def get_links (item):
+    logger.info()
+    results =[]
+    channel = __import__('channels.%s' % item.from_channel, None, None, ["channels.%s" % item.from_channel])
+    if len(link_list) <= max_links:
+        link_list.extend(getattr(channel, item.from_action)(item))
diff --git a/plugin.video.alfa/channels/seriesblanco.json b/plugin.video.alfa/channels/seriesblanco.json
old mode 100755
new mode 100644
index 1b326714..cab8afd1
--- a/plugin.video.alfa/channels/seriesblanco.json
+++ b/plugin.video.alfa/channels/seriesblanco.json
@@ -1,31 +1,22 @@
 {
   "id": "seriesblanco",
-  "name": "Seriesblanco",
-  "active": false,
+  "name": "SeriesBlanco",
+  "active": true,
   "adult": false,
   "language": ["cast", "lat"],
-  "thumbnail": "seriesblanco.png",
-  "banner": "seriesblanco.png",
+  "thumbnail": "https://s22.postimg.cc/nucz720sx/image.png",
+  "banner": "",
   "categories": [
-    "tvshow",
-    "vos"
+    "tvshow"
   ],
   "settings": [
     {
       "id": "include_in_global_search",
       "type": "bool",
       "label": "Incluir en busqueda global",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_series",
-      "type": "bool",
-      "label": "Incluir en Novedades - Episodios de series",
-      "default": true,
-      "enabled": true,
-      "visible": true
+      "default": false,
+      "enabled": false,
+      "visible": false
     },
     {
       "id": "filter_languages",
@@ -36,26 +27,10 @@
       "visible": true,
       "lvalues": [
         "No filtrar",
-        "Español",
-        "Inglés",
-        "Latino",
-        "VO",
-        "VOS",
-        "VOSI",
-        "OVOS"
-      ]
-    },
-    {
-      "id": "filterlinks",
-      "type": "list",
-      "label": "Mostrar enlaces de tipo...",
-      "default": 2,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "Solo Descarga",
-        "Solo Online",
-        "No filtrar"
+		"Cast",
+		"Lat",
+        "VOSE",
+        "VO"
       ]
     }
   ]
diff --git a/plugin.video.alfa/channels/seriesblanco.py b/plugin.video.alfa/channels/seriesblanco.py
index 529d9fe1..d6a81de0 100644
--- a/plugin.video.alfa/channels/seriesblanco.py
+++ b/plugin.video.alfa/channels/seriesblanco.py
@@ -1,369 +1,353 @@
 # -*- coding: utf-8 -*-
+# -*- Channel SeriesBlanco -*-
+# -*- Created for Alfa-addon -*-
+# -*- By the Alfa Develop Group -*-
 
 import re
-import urlparse
 
+from channels import autoplay
 from channels import filtertools
-from channelselector import get_thumb
 from core import httptools
-from core import scrapertoolsV2
+from core import scrapertools
 from core import servertools
+from core import tmdb
 from core.item import Item
 from platformcode import config, logger
-from core import tmdb
-from channels import autoplay
+from channelselector import get_thumb
 
+host = 'http://seriesblanco.xyz/'
 
-HOST = "https://seriesblanco.com/"
-IDIOMAS = {'es': 'Español', 'en': 'Inglés', 'la': 'Latino', 'vo': 'VO', 'vos': 'VOS', 'vosi': 'VOSI', 'otro': 'OVOS'}
-list_idiomas = IDIOMAS.values()
-list_language = ['default']
-CALIDADES = ['SD', 'HDiTunes', 'Micro-HD-720p', 'Micro-HD-1080p', '1080p', '720p']
-list_quality = CALIDADES
-
-list_servers = ['powvideo',
-                'streamcloud',
-                'openload',
-                'flashx',
-                'streamplay',
-                'nowvideo',
-                'gamovideo',
-                'kingvid',
-                'vidabc',
-                'streamixcloud'
-                ]
+IDIOMAS = {'es': 'Cast', 'la': 'Lat', 'vos': 'VOSE', 'vo': 'VO'}
+list_language = IDIOMAS.values()
+list_quality = ['SD', 'Micro-HD-720p', '720p', 'HDitunes', 'Micro-HD-1080p' ]
+list_servers = ['powvideo','yourupload', 'openload', 'gamovideo', 'flashx', 'clipwatching', 'streamango', 'streamcloud']
 
 
 def mainlist(item):
     logger.info()
 
-    thumb_series = get_thumb("channels_tvshow.png")
-    thumb_series_az = get_thumb("channels_tvshow_az.png")
-    thumb_buscar = get_thumb("search.png")
-
-    itemlist = list()
-
     autoplay.init(item.channel, list_servers, list_quality)
-    itemlist.append(Item(channel=item.channel, title="Listado alfabético", action="series_listado_alfabetico",
-                         thumbnail=thumb_series_az))
-    itemlist.append(Item(channel=item.channel, title="Todas las series", action="series",
-                         url=urlparse.urljoin(HOST, "listado/"), thumbnail=thumb_series))
-    itemlist.append(
-        Item(channel=item.channel, title="Capítulos estrenados recientemente", action="home_section",
-             extra="Series Online : Capítulos estrenados recientemente",
-             url=HOST, thumbnail=thumb_series))
-    itemlist.append(Item(channel=item.channel, title="Series más vistas", action="series", extra="Series Más vistas",
-                         url=urlparse.urljoin(HOST, "listado-visto/"), thumbnail=thumb_series))
-    itemlist.append(Item(channel=item.channel, title="Últimas fichas creadas", action="series",
-                         url=urlparse.urljoin(HOST, "fichas_creadas/"), thumbnail=thumb_series))
-    itemlist.append(Item(channel=item.channel, title="Series por género", action="generos",
-                         url=HOST, thumbnail=thumb_series))
-    itemlist.append(
-        Item(channel=item.channel, title="Buscar...", action="search", url=urlparse.urljoin(HOST, "finder.php"),
-             thumbnail=thumb_buscar))
 
-    itemlist = filtertools.show_option(itemlist, item.channel, list_idiomas, CALIDADES)
+    itemlist = []
 
+    itemlist.append(Item(channel=item.channel,
+                         title="Nuevos Capitulos",
+                         action="new_episodes",
+                         thumbnail=get_thumb('new_episodes', auto=True),
+                         url=host))
+
+    itemlist.append(Item(channel=item.channel,
+                         title="Todas",
+                         action="list_all",
+                         thumbnail=get_thumb('all', auto=True),
+                         url=host + 'listado/',
+                         ))
+
+    itemlist.append(Item(channel=item.channel,
+                         title="Generos",
+                         action="section",
+                         thumbnail=get_thumb('genres', auto=True),
+                         url=host,
+                         ))
+
+    itemlist.append(Item(channel=item.channel,
+                         title="A - Z",
+                         action="section",
+                         thumbnail=get_thumb('alphabet', auto=True),
+                         url=host+'listado/', ))
+
+    itemlist.append(Item(channel=item.channel,
+                         title="Buscar",
+                         action="search",
+                         thumbnail=get_thumb('search', auto=True)))
+
+    itemlist = filtertools.show_option(itemlist, item.channel, list_language, list_quality)
     autoplay.show_option(item.channel, itemlist)
+
     return itemlist
 
+def get_source(url):
+    logger.info()
+    data = httptools.downloadpage(url).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    return data
 
-def home_section(item):
-    logger.info("section = %s" % item.extra)
+def list_all(item):
+    logger.info()
 
-    pattern = "['\"]panel-title['\"]>[^/]*%s(.*?)(?:panel-title|\Z)" % item.extra
-    # logger.debug("pattern = %s" % pattern)
-
-    data = httptools.downloadpage(item.url).data
-    result = re.search(pattern, data, re.MULTILINE | re.DOTALL)
-
-    if result:
-        # logger.debug("found section: {0}".format(result.group(1)))
-        item.extra = 1
-        return extract_series_from_data(item, result.group(1))
-
-    logger.debug("No match")
-    return []
-
-
-def extract_series_from_data(item, data):
     itemlist = []
-    episode_pattern = re.compile('/capitulo-([0-9]+)/')
-    shows = re.findall("<a.+?href=['\"](?P<url>/serie[^'\"]+)[^<]*<img[^>]*src=['\"](?P<img>http[^'\"]+).*?"
-                       "(?:alt|title)=['\"](?P<name>[^'\"]+)", data)
-    for url, img, name in shows:
-        try:
-            name.decode('utf-8')
-        except UnicodeError:
-            name = unicode(name, "iso-8859-1", errors="replace").encode("utf-8")
+    data = get_source(item.url)
+    contentSerieName = ''
 
-        name = name.strip()
-        # logger.debug("Show found: %s -> %s (%s)" % (name, url, img))
-        if not episode_pattern.search(url):
-            action = "episodios"
-        else:
-            action = "findvideos"
+    patron = "<div style='float.*?<a href='(.*?)'>.*?src='(.*?)' title='(.*?)'"
+    matches = re.compile(patron, re.DOTALL).findall(data)
 
-        context = filtertools.context(item, list_idiomas, CALIDADES)
-        context2 = autoplay.context
-        context.extend(context2)
 
-        itemlist.append(item.clone(title=name, url=urlparse.urljoin(HOST, url),
-                                   action=action, show=name, contentSerieName=name,
-                                   thumbnail=img,
-                                   context=context))
+    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
 
-    more_pages = re.search('pagina=([0-9]+)">>>', data)
-    if more_pages:
-        # logger.debug("Adding next page item")
-        itemlist.append(item.clone(title="Siguiente >>", extra=item.extra + 1))
+        url = host + scrapedurl
+        thumbnail = scrapedthumbnail
+        title = scrapertools.decodeHtmlentities(scrapedtitle)
 
-    if item.extra > 1:
-        # logger.debug("Adding previous page item")
-        itemlist.append(item.clone(title="<< Anterior", extra=item.extra - 1))
+        itemlist.append(Item(channel=item.channel,
+                             action='seasons',
+                             title=title,
+                             url=url,
+                             thumbnail=thumbnail,
+                             contentSerieName=scrapedtitle,
+                             context=filtertools.context(item, list_language, list_quality),
+                             ))
 
     tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # #Paginacion
+
+    if itemlist != []:
+        base_page = scrapertools.find_single_match(item.url,'(.*?)?')
+        next_page = scrapertools.find_single_match(data, '</span><a href=?pagina=2>>></a>')
+        if next_page != '':
+            itemlist.append(Item(channel=item.channel,
+                                 action="lista",
+                                 title='Siguiente >>>',
+                                 url=base_page+next_page,
+                                 thumbnail='https://s16.postimg.cc/9okdu7hhx/siguiente.png',
+                                 ))
     return itemlist
 
-
-def series(item):
+def section(item):
     logger.info()
-    if not hasattr(item, 'extra') or not isinstance(item.extra, int):
-        item.extra = 1
-
-    if '?' in item.url:
-        merger = '&'
-    else:
-        merger = '?'
-
-    page_url = "%s%spagina=%s" % (item.url, merger, item.extra)
-    logger.info("url = %s" % page_url)
-
-    data = scrapertoolsV2.decodeHtmlentities(httptools.downloadpage(page_url).data)
-    return extract_series_from_data(item, data)
-
-
-def series_listado_alfabetico(item):
-    logger.info()
-
-    return [item.clone(action="series", title=letra, url=urlparse.urljoin(HOST, "listado-%s/" % letra))
-            for letra in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
-
-
-def generos(item):
-    logger.info()
-    data = httptools.downloadpage(item.url).data
-
-    result = re.findall("href=['\"](?P<url>/listado/[^'\"]+)['\"][^/]+/i>\s*(?P<genero>[^<]+)", data)
-    return [item.clone(action="series", title=genero, url=urlparse.urljoin(item.url, url)) for url, genero in result]
-
-
-def newest(categoria):
-    logger.info("categoria: %s" % categoria)
-    itemlist = []
-    try:
-        if categoria == 'series':
-            itemlist = home_section(Item(extra=CAPITULOS_DE_ESTRENO_STR, url=HOST))
-
-    # Se captura la excepción, para no interrumpir al canal novedades si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-    return itemlist
-
-
-def search(item, texto):
-    logger.info("%s" % texto)
-    texto = texto.replace(" ", "+")
 
     itemlist = []
+    data = get_source(item.url)
+    if item.title == 'Generos':
+        patron = '<li><a href=([^ ]+)><i class=fa fa-bookmark-o></i> (.*?)</a></li>'
+    elif item.title == 'A - Z':
+        patron = "<a dir='ltr' href=(.*?) class='label label-primary'>(.*?)</a>"
+    matches = re.compile(patron, re.DOTALL).findall(data)
 
-    try:
-        post = "query=%s" % texto
-        data = httptools.downloadpage(item.url, post=post).data
-        data = re.sub(r"\n|\r|\t|\s{2}", "", data)
-        shows = re.findall("<a href=['\"](?P<url>/serie[^'\"]+)['\"].*?<img src=['\"](?P<img>[^'\"]+)['\"].*?"
-                           "id=['\"]q2[1\"] name=['\"]q2['\"] value=['\"](?P<title>.*?)['\"]", data)
-
-        for url, img, title in shows:
-            title = title.strip()
-            itemlist.append(item.clone(title=title, url=urlparse.urljoin(HOST, url), action="episodios", show=title,
-                                       thumbnail=img, context=filtertools.context(item, list_idiomas, CALIDADES),
-                                       contentSerieName=title))
-
-    # Se captura la excepción, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
+    for scrapedurl, scrapedtitle in matches:
 
+        if item.title == 'Generos':
+            url = host + scrapedurl
+        else:
+            url = scrapedurl
+        title = scrapedtitle
+        itemlist.append(Item(channel=item.channel,
+                             action='list_all',
+                             title=title,
+                             url=url
+                             ))
     return itemlist
 
+def seasons(item):
+    logger.info()
+    itemlist = []
+    data = get_source(item.url)
+    patron = '<span itemprop=seasonNumber class=fa fa-arrow-down>.*?Temporada (\d+) '
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    infoLabels=item.infoLabels
+    for scrapedseason in matches:
+        url = item.url
+        title = 'Temporada %s' % scrapedseason
+        contentSeasonNumber = scrapedseason
+        infoLabels['season'] = contentSeasonNumber
+        thumbnail = item.thumbnail
+        itemlist.append(Item(channel=item.channel,
+                             action="episodesxseason",
+                             title=title,
+                             url=url,
+                             thumbnail=thumbnail,
+                             contentSeasonNumber=contentSeasonNumber,
+                             infoLabels=infoLabels
+                             ))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    if config.get_videolibrary_support() and len(itemlist) > 0:
+        itemlist.append(Item(channel=item.channel,
+                             title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]',
+                             url=item.url,
+                             action="add_serie_to_library",
+                             extra="episodios",
+                             contentSerieName=item.contentSerieName,
+                             ))
+
+    return itemlist
 
 def episodios(item):
-    logger.info("%s - %s" % (item.title, item.url))
-
+    logger.info()
     itemlist = []
+    templist = seasons(item)
+    for tempitem in templist:
+        itemlist += episodesxseason(tempitem)
+    return itemlist
 
-    # Descarga la página
-    data = httptools.downloadpage(item.url).data
+def episodesxseason(item):
+    logger.info()
+    itemlist = []
+    data = get_source(item.url)
 
-    fanart = scrapertoolsV2.find_single_match(data, "background-image[^'\"]+['\"]([^'\"]+)")
-    plot = scrapertoolsV2.find_single_match(data, "id=['\"]profile2['\"]>\s*(.*?)\s*</div>")
-
-    # logger.debug("fanart: %s" % fanart)
-    # logger.debug("plot: %s" % plot)
-
-    episodes = re.findall("<tr.*?href=['\"](?P<url>[^'\"]+).+?>(?P<title>.+?)</a>.*?<td>(?P<flags>.*?)</td>", data,
-                          re.MULTILINE | re.DOTALL)
-    for url, title, flags in episodes:
-        title = re.sub("<span[^>]+>", "", title).replace("</span>", "")
-        idiomas = " ".join(["[%s]" % IDIOMAS.get(language, "OVOS") for language in
-                            re.findall("banderas/([^\.]+)", flags, re.MULTILINE)])
-        filter_lang = idiomas.replace("[", "").replace("]", "").split(" ")
-        display_title = "%s - %s %s" % (item.show, title, idiomas)
-
-        season_episode = scrapertoolsV2.get_season_and_episode(title).split('x')
-        item.infoLabels['season']= season_episode[0]
-        item.infoLabels['episode'] = season_episode[1]
-        # logger.debug("Episode found %s: %s" % (display_title, urlparse.urljoin(HOST, url)))
-        itemlist.append(item.clone(title=display_title, url=urlparse.urljoin(HOST, url),
-                                   action="findvideos", plot=plot, fanart=fanart, language=filter_lang))
+    season = item.contentSeasonNumber
+    season_data = scrapertools.find_single_match(data, '<div id=collapse%s.*?panel-primary' % season)
+    patron = "<td><a href='([^ ]+)'.*?itemprop='episodeNumber'>%s+x(\d+)</span> - (.*?) </a>.*?(/banderas.*?)</td>" % season
+    matches = re.compile(patron, re.DOTALL).findall(season_data)
+    infoLabels = item.infoLabels
+    for scrapedurl, scraped_episode, scrapedtitle, lang_data in matches:
+        url = host + scrapedurl
+        title = '%sx%s - %s' % (season, scraped_episode, scrapedtitle.strip())
+        infoLabels['episode'] = scraped_episode
+        thumbnail = item.thumbnail
+        title, language = add_language(title, lang_data)
+        itemlist.append(Item(channel=item.channel,
+                             action="findvideos",
+                             title=title,
+                             url=url,
+                             thumbnail=thumbnail,
+                             language=language,
+                             infoLabels=infoLabels
+                             ))
 
     tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    itemlist = filtertools.get_links(itemlist, item, list_idiomas, CALIDADES)
 
-
-    if config.get_videolibrary_support() and len(itemlist) > 0:
-        itemlist.append(
-            item.clone(title="Añadir esta serie a la videoteca", action="add_serie_to_library", extra="episodios"))
+    itemlist = filtertools.get_links(itemlist, item, list_language)
 
     return itemlist
 
+def new_episodes(item):
+    logger.info()
+    itemlist = []
 
-def parse_videos(item, type_str, data):
-    video_patterns_str = [
-        '<tr.+?<span>(?P<date>.+?)</span>.*?banderas/(?P<language>[^\.]+).+?href="(?P<link>[^"]+).+?servidores/'
-        '(?P<server>[^\.]+).*?</td>.*?<td>.*?<span>(?P<uploader>.+?)</span>.*?<span>(?P<quality>.*?)</span>',
-        '<tr.+?banderas/(?P<language>[^\.]+).+?<td[^>]*>(?P<date>.+?)</td>.+?href=[\'"](?P<link>[^\'"]+)'
-        '.+?servidores/(?P<server>[^\.]+).*?</td>.*?<td[^>]*>.*?<a[^>]+>(?P<uploader>.+?)</a>.*?</td>.*?<td[^>]*>'
-        '(?P<quality>.*?)</td>.*?</tr>'
-    ]
+    data = get_source(item.url)
 
-    for v_pat_str in video_patterns_str:
-        v_patt_iter = re.compile(v_pat_str, re.MULTILINE | re.DOTALL).finditer(data)
+    patron = "padding-left:15px'><a href=(.*?) >.*?src='(.*?)' title=.*? alt='(.*?) (\d+x\d+)'.*?"
+    patron += "<span class='strong'>.*?</span>(.*?)</button></a></div>"
+    matches = re.compile(patron, re.DOTALL).findall(data)
 
-        itemlist = []
-
-        for vMatch in v_patt_iter:
-            v_fields = vMatch.groupdict()
-            quality = v_fields.get("quality")
-
-            # FIX para veces que añaden el idioma en los comentarios
-            regex = re.compile('sub-inglés-?', re.I)
-            quality = regex.sub("", quality)
-            # quality = re.sub(r"sub-inglés-?", "", quality, flags=re.IGNORECASE)
-
-            if not quality:
-                quality = "SD"
-
-            # FIX para los guiones en la calidad y no tener que añadir otra opción en la lista de calidades
-            if quality.startswith("MicroHD"):
-                regex = re.compile('microhd', re.I)
-                quality = regex.sub("Micro-HD-", quality)
-                # quality = re.sub(r"microhd", "Micro-HD-", quality, flags=re.IGNORECASE)
-            server = v_fields.get("server")
-            title = "%s en %s [%s] [%s] (%s: %s)" % (type_str, v_fields.get("server"),
-                                                     IDIOMAS.get(v_fields.get("language"), "OVOS"), quality,
-                                                     v_fields.get("uploader"), v_fields.get("date"))
-            itemlist.append(
-                item.clone(title=title, fulltitle=item.title, url=urlparse.urljoin(HOST, v_fields.get("link")),
-                           action="play", language=IDIOMAS.get(v_fields.get("language"), "OVOS"),
-                           quality=quality, server= server))
-
-        if len(itemlist) > 0:
-            return itemlist
-
-    return []
+    for scrapedurl, scrapedthumbnail, scrapedtitle, scrapedinfo, lang_data in matches:
 
 
-def extract_videos_section(data):
-    return re.findall("panel-title[^>]*>\s*([VvDd].+?)</div>[^<]*</div>[^<]*</div>", data, re.MULTILINE | re.DOTALL)
+        url = host+scrapedurl
+        thumbnail = scrapedthumbnail
+        scrapedinfo = scrapedinfo.split('x')
+        season = scrapedinfo[0]
+        episode = scrapedinfo[1]
+        title = '%s - %sx%s' % (scrapedtitle, season, episode )
+        title, language = add_language(title, lang_data)
+        itemlist.append(Item(channel=item.channel,
+                             action='seasons',
+                             title=title,
+                             url=url,
+                             thumbnail=thumbnail,
+                             language=language,
+                              ))
+        tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+def add_language(title, string):
+    logger.info()
+    languages = scrapertools.find_multiple_matches(string, '/banderas/(.*?).png')
+    language = []
+    for lang in languages:
+
+        if 'jap' in lang or lang not in IDIOMAS:
+            lang = 'vos'
+
+        if len(languages) == 1:
+            language = IDIOMAS[lang]
+            if not config.get_setting('unify'):
+                title = '%s [%s]' % (title, language)
+        else:
+            language.append(IDIOMAS[lang])
+            if not config.get_setting('unify'):
+                title = '%s [%s]' % (title, IDIOMAS[lang])
+
+    return title, language
 
 
 def findvideos(item):
-    logger.info("%s = %s" % (item.show, item.url))
+    logger.info()
 
-    # Descarga la página
-    data = httptools.downloadpage(item.url).data
-    # logger.info(data)
+    itemlist = []
 
-    online = extract_videos_section(data)
-    try:
-        filtro_enlaces = config.get_setting("filterlinks", item.channel)
-    except:
-        filtro_enlaces = 2
+    data = get_source(item.url)
 
-    list_links = []
+    patron = "<a href=([^ ]+) target=_blank><img src='/servidores/(.*?).(?:png|jpg)'.*?sno.*?"
+    patron += "<span>(.*?)<.*?(/banderas.*?)td"
+    matches = re.compile(patron, re.DOTALL).findall(data)
 
-    if filtro_enlaces != 0:
-        list_links.extend(parse_videos(item, "Ver", online[-2]))
 
-    if filtro_enlaces != 1:
-        list_links.extend(parse_videos(item, "Descargar", online[-1]))
-    list_links = filtertools.get_links(list_links, item, list_idiomas, CALIDADES)
+    for scrapedurl, server, quality, lang_data in matches:
 
-    for i in range(len(list_links)):
-        a=list_links[i].title
-        b=a[a.find("en") + 2:]
-        c=b.split('[')
-        d=c[0].rstrip( )
-        d=d.lstrip( )
-        list_links[i].server=d.replace("streamix", "streamixcloud")
-        list_links[i].server=d.replace("uploaded", "uploadedto")
+        title = server.capitalize()
+        if quality == '':
+            quality = 'SD'
+        title = '%s [%s]' % (title, quality)
+        title, language = add_language(title, lang_data)
+        thumbnail = item.thumbnail
 
-    list_links = servertools.get_servers_itemlist(list_links)
-    autoplay.start(list_links, item)
+        enlace_id, serie_id, se, ep = scrapertools.find_single_match(scrapedurl,'enlace(\d+)/(\d+)/(\d+)/(\d+)/')
 
-    return list_links
+        url = host + 'ajax/load_enlace.php?serie=%s&temp=%s&cap=%s&id=%s' % (serie_id, se, ep, enlace_id)
+        itemlist.append(Item(channel=item.channel,
+                             title=title,
+                             url=url,
+                             action="play",
+                             thumbnail=thumbnail,
+                             server=server,
+                             quality=quality,
+                             language=language,
+                             infoLabels=item.infoLabels
+                             ))
+    # Requerido para FilterTools
+
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    # Requerido para AutoPlay
+
+    autoplay.start(itemlist, item)
+
+    return sorted(itemlist, key=lambda it: it.language)
 
 
 def play(item):
-    logger.info("%s - %s = %s" % (item.show, item.title, item.url))
-    if item.url.startswith(HOST):
-        data = httptools.downloadpage(item.url).data
-
-        ajax_link = re.findall("loadEnlace\((\d+),(\d+),(\d+),(\d+)\)", data)
-        ajax_data = ""
-        for serie, temp, cap, linkID in ajax_link:
-            # logger.debug(
-            #     "Ajax link request: Serie = %s - Temp = %s - Cap = %s - Link = %s" % (serie, temp, cap, linkID))
-            ajax_data += httptools.downloadpage(
-                HOST + '/ajax/load_enlace.php?serie=' + serie + '&temp=' + temp + '&cap=' + cap + '&id=' + linkID).data
-
-        if ajax_data:
-            data = ajax_data
-
-        patron = "window.location.href\s*=\s*[\"']([^\"']+)'"
-        url = scrapertoolsV2.find_single_match(data, patron)
-
-    else:
-        url = item.url
-
-    itemlist = servertools.find_video_items(item=item,data=url)
-
-    titulo = scrapertoolsV2.find_single_match(item.fulltitle, "^(.*?)\s\[.+?$")
-    if titulo:
-        titulo += " [%s]" % item.language
-
+    logger.info()
+    itemlist = []
+    data = httptools.downloadpage(item.url, follow_redirects=False).data
+    itemlist = servertools.find_video_items(data=data)
     for videoitem in itemlist:
-        if titulo:
-            videoitem.title = titulo
-        else:
-            videoitem.title = item.title
-        videoitem.channel = item.channel
+        videoitem.infoLabels = item.infoLabels
+
 
     return itemlist
+
+def search_results(item):
+    logger.info()
+    itemlist = []
+
+    data = httptools.downloadpage(host + 'finder.php', post=item.post).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    patron = "<a href='(.*?)'>.*?src=(.*?) style.*?value=(.*?)>"
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedthumb, scrapedtitle in matches:
+        itemlist.append(Item(channel=item.channel,
+                             title=scrapedtitle,
+                             url=host+scrapedurl,
+                             action="seasons",
+                             thumbnail=scrapedthumb,
+                             contentSerieName=scrapedtitle,
+                             context=filtertools.context(item, list_language, list_quality)
+                             ))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+def search(item, texto):
+    logger.info()
+    import urllib
+    if texto != '':
+        post = {'query':texto}
+        post = urllib.urlencode(post)
+        item.post = post
+
+        return search_results(item)
diff --git a/plugin.video.alfa/channels/veseriesonline.py b/plugin.video.alfa/channels/veseriesonline.py
index b1ba3b7b..0b9aeef0 100644
--- a/plugin.video.alfa/channels/veseriesonline.py
+++ b/plugin.video.alfa/channels/veseriesonline.py
@@ -183,50 +183,56 @@ def findvideos(item):
 
     # listado de opciones links_url
 
-    data = get_source(links_url)
-    patron = 'content ><h2>(.*?)</h2>.*?class=video.*?src=(.*?) scrolling'
-    matches = re.compile(patron, re.DOTALL).findall(data)
+    try:
+        data = get_source(links_url)
+        patron = 'content ><h2>(.*?)</h2>.*?class=video.*?src=(.*?) scrolling'
+        matches = re.compile(patron, re.DOTALL).findall(data)
 
-    for lang_data, scrapedurl in matches:
-        if 'Latino' in lang_data:
-            language = 'Lat'
-        elif 'Español' in lang_data:
-            language = 'Cast'
-        else:
-            language = 'VOSE'
-        hidden_url = scrapedurl.replace('/i/', '/r/')
-        data = get_source(hidden_url)
-        url = scrapertools.find_single_match(data, ':url content=(.*?)>')
-        title = '%s '+ '[%s]' % language
-        if url != '':
-            itemlist.append(Item(channel=item.channel, title=title, url=url, action='play', language=language,
-                                 infoLabels=item.infoLabels))
+        for lang_data, scrapedurl in matches:
+            if 'Latino' in lang_data:
+                language = 'Lat'
+            elif 'Español' in lang_data:
+                language = 'Cast'
+            else:
+                language = 'VOSE'
+            hidden_url = scrapedurl.replace('/i/', '/r/')
+            data = get_source(hidden_url)
+            url = scrapertools.find_single_match(data, ':url content=(.*?)>')
+            title = '%s '+ '[%s]' % language
+            if url != '':
+                itemlist.append(Item(channel=item.channel, title=title, url=url, action='play', language=language,
+                                     infoLabels=item.infoLabels))
+    except:
+        pass
 
     # listado de enlaces online_url
-    data = get_source(online_url)
-    patron = '<i class=lang-(.*?)>.*?href=(.*?) '
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-    for lang_data, scrapedurl in matches:
-        if 'lat' in lang_data:
-            language = 'Lat'
-        elif 'spa' in lang_data:
-            language = 'Cast'
-        elif 'eng' in lang_data:
-            language = 'VOSE'
-        else:
-            language = 'VO'
-        video_id = scrapertools.find_single_match(scrapedurl, 'index.php/(\d+)/')
-        new_url = '%s%s%s%s' % (host, 'ext/index-include.php?id=', video_id, '&tipo=1')
-        data = get_source(new_url)
-        video_url = scrapertools.find_single_match(data, '<div class=container><a href=(.*?)>')
-        video_url = video_url.replace('enlace.php', 'r')
-        data = httptools.downloadpage(video_url, follow_redirects=False)
-        url = data.headers['location']
-        title = '%s '+ '[%s]' % language
-        if url != '':
-            itemlist.append(Item(channel=item.channel, title=title, url=url, action='play', language=language,
-                                 infoLabels=item.infoLabels))
+    try:
+        data = get_source(online_url)
+        patron = '<i class=lang-(.*?)>.*?href=(.*?) '
+        matches = re.compile(patron, re.DOTALL).findall(data)
+        scrapertools.printMatches(matches)
+        for lang_data, scrapedurl in matches:
+            if 'lat' in lang_data:
+                language = 'Lat'
+            elif 'spa' in lang_data:
+                language = 'Cast'
+            elif 'eng' in lang_data:
+                language = 'VOSE'
+            else:
+                language = 'VO'
+            video_id = scrapertools.find_single_match(scrapedurl, 'index.php/(\d+)/')
+            new_url = '%s%s%s%s' % (host, 'ext/index-include.php?id=', video_id, '&tipo=1')
+            data = get_source(new_url)
+            video_url = scrapertools.find_single_match(data, '<div class=container><a href=(.*?)>')
+            video_url = video_url.replace('enlace.php', 'r')
+            data = httptools.downloadpage(video_url, follow_redirects=False)
+            url = data.headers['location']
+            title = '%s '+ '[%s]' % language
+            if url != '':
+                itemlist.append(Item(channel=item.channel, title=title, url=url, action='play', language=language,
+                                     infoLabels=item.infoLabels))
+    except:
+        pass
 
     itemlist = servertools.get_servers_itemlist(itemlist, lambda i: i.title % i.server.capitalize())
 
diff --git a/plugin.video.alfa/channelselector.py b/plugin.video.alfa/channelselector.py
index 301553c3..a0d346a5 100644
--- a/plugin.video.alfa/channelselector.py
+++ b/plugin.video.alfa/channelselector.py
@@ -196,6 +196,22 @@ def filterchannels(category, view="thumb_"):
 
         channelslist.insert(0, Item(title=config.get_localized_string(60088), action="mainlist", channel="url",
                                     thumbnail=channel_parameters["thumbnail"], type="generic", viewmode="list"))
+    if category in ['movie', 'tvshow']:
+        titles = ['Mas Populares', 'Mejor Valoradas', 'Ahora en cines', 'En Emision', 'Por Genero']
+        ids = ['popular', 'top_rated', 'now_playing', 'on_the_air']
+        for x in range(0,3):
+            if x == 2 and category != 'movie':
+                title=titles[x+1]
+                id = ids[x+1]
+            else:
+                title=titles[x]
+                id = ids[x]
+            channelslist.insert(x,
+                Item(channel='search', action='discover_list', title=title, search_type='list',
+                     list_type='%s/%s' % (category.replace('show',''), id), thumbnail=get_thumb(id+".png")))
+
+        channelslist.insert(3, Item(channel='search', action='genres_menu', title='Generos',
+                                    type=category.replace('show',''), thumbnail=get_thumb("genres.png")))
 
     return channelslist
 
diff --git a/plugin.video.alfa/core/tmdb.py b/plugin.video.alfa/core/tmdb.py
old mode 100755
new mode 100644
index 1ba25685..d58936c6
--- a/plugin.video.alfa/core/tmdb.py
+++ b/plugin.video.alfa/core/tmdb.py
@@ -536,6 +536,32 @@ def completar_codigos(item):
             item.infoLabels['url_scraper'].append(url_scraper)
 
 
+def discovery(item):
+    from core.item import Item
+    from platformcode import unify
+
+    if item.search_type == 'discover':
+        listado = Tmdb(discover={'url':'discover/%s' % item.type, 'with_genres':item.list_type, 'language':'es',
+                                 'page':item.page})
+
+    elif item.search_type == 'list':
+        if item.page == '':
+            item.page = '1'
+        listado = Tmdb(list={'url': item.list_type, 'language':'es', 'page':item.page})
+
+    logger.debug(listado.get_list_resultados())
+    result = listado.get_list_resultados()
+
+    return result
+
+def get_genres(type):
+    lang = 'es'
+    genres = Tmdb(tipo=type)
+
+    return genres.dic_generos[lang]
+
+
+
 # Clase auxiliar
 class ResultDictDefault(dict):
     # Python 2.4
@@ -762,6 +788,7 @@ class Tmdb(object):
         self.busqueda_year = kwargs.get('year', '')
         self.busqueda_filtro = kwargs.get('filtro', {})
         self.discover = kwargs.get('discover', {})
+        self.list = kwargs.get('list', {})
 
         # Reellenar diccionario de generos si es necesario
         if (self.busqueda_tipo == 'movie' or self.busqueda_tipo == "tv") and \
@@ -793,6 +820,9 @@ class Tmdb(object):
         elif self.discover:
             self.__discover()
 
+        elif self.list:
+            self.__list()
+
         else:
             logger.debug("Creado objeto vacio")
 
@@ -947,6 +977,65 @@ class Tmdb(object):
             logger.error(msg)
             return 0
 
+    def __list(self, index_results=0):
+        self.result = ResultDictDefault()
+        results = []
+        total_results = 0
+        total_pages = 0
+
+        # Ejemplo self.discover: {'url': 'movie/', 'with_cast': '1'}
+        # url: Método de la api a ejecutar
+        # resto de claves: Parámetros de la búsqueda concatenados a la url
+        type_search = self.list.get('url', '')
+        if type_search:
+            params = []
+            for key, value in self.list.items():
+                if key != "url":
+                    params.append("&"+key + "=" + str(value))
+            # http://api.themoviedb.org/3/movie/popolar?api_key=a1ab8b8669da03637a4b98fa39c39228&&language=es
+            url = ('http://api.themoviedb.org/3/%s?api_key=a1ab8b8669da03637a4b98fa39c39228%s'
+                   % (type_search, ''.join(params)))
+
+            logger.info("[Tmdb.py] Buscando %s:\n%s" % (type_search, url))
+            resultado = self.get_json(url)
+
+            total_results = resultado.get("total_results", -1)
+            total_pages = resultado.get("total_pages", 1)
+
+            if total_results > 0:
+                results = resultado["results"]
+                if self.busqueda_filtro and results:
+                    # TODO documentar esta parte
+                    for key, value in dict(self.busqueda_filtro).items():
+                        for r in results[:]:
+                            if key not in r or r[key] != value:
+                                results.remove(r)
+                                total_results -= 1
+            elif total_results == -1:
+                results = resultado
+
+            if index_results >= len(results):
+                logger.error(
+                    "La busqueda de '%s' no dio %s resultados" % (type_search, index_results))
+                return 0
+
+        # Retornamos el numero de resultados de esta pagina
+        if results:
+            self.results = results
+            self.total_results = total_results
+            self.total_pages = total_pages
+            if total_results > 0:
+                self.result = ResultDictDefault(self.results[index_results])
+            else:
+                self.result = results
+            return len(self.results)
+        else:
+            # No hay resultados de la busqueda
+            logger.error("La busqueda de '%s' no dio resultados" % type_search)
+            return 0
+
+
+
     def __discover(self, index_results=0):
         self.result = ResultDictDefault()
         results = []
diff --git a/plugin.video.alfa/platformcode/platformtools.py b/plugin.video.alfa/platformcode/platformtools.py
index c9502acb..bff09bc0 100644
--- a/plugin.video.alfa/platformcode/platformtools.py
+++ b/plugin.video.alfa/platformcode/platformtools.py
@@ -218,9 +218,9 @@ def render_items(itemlist, parent_item):
         context_commands = set_context_commands(item, parent_item)
 
         # Añadimos el item
-        if config.get_platform(True)['num_version'] >= 17.0:
+        if config.get_platform(True)['num_version'] >= 17.0 and parent_item.list_type == '':
             listitem.addContextMenuItems(context_commands)
-        else:
+        elif parent_item.list_type == '':
             listitem.addContextMenuItems(context_commands, replaceItems=True)
 
         if not item.totalItems:
@@ -239,7 +239,18 @@ def render_items(itemlist, parent_item):
         xbmcplugin.setContent(int(sys.argv[1]), "movies")
 
     # Fijamos el "breadcrumb"
-    xbmcplugin.setPluginCategory(handle=int(sys.argv[1]), category=parent_item.category.capitalize())
+    if parent_item.list_type == '':
+        breadcrumb = parent_item.category.capitalize()
+    else:
+        if 'similar' in parent_item.list_type:
+            if parent_item.contentTitle != '':
+                breadcrumb = 'Similares (%s)' % parent_item.contentTitle
+            else:
+                breadcrumb = 'Similares (%s)' % parent_item.contentSerieName
+        else:
+            breadcrumb = 'Busqueda'
+
+    xbmcplugin.setPluginCategory(handle=int(sys.argv[1]), category=breadcrumb)
 
     # No ordenar items
     xbmcplugin.addSortMethod(handle=int(sys.argv[1]), sortMethod=xbmcplugin.SORT_METHOD_NONE)
@@ -424,7 +435,6 @@ def set_context_commands(item, parent_item):
             else:
                 context_commands.append(
                     (command["title"], "XBMC.RunPlugin(%s?%s)" % (sys.argv[0], item.clone(**command).tourl())))
-
     # Opciones segun criterios, solo si el item no es un tag (etiqueta), ni es "Añadir a la videoteca", etc...
     if item.action and item.action not in ["add_pelicula_to_library", "add_serie_to_library", "buscartrailer"]:
         # Mostrar informacion: si el item tiene plot suponemos q es una serie, temporada, capitulo o pelicula
@@ -460,7 +470,8 @@ def set_context_commands(item, parent_item):
             elif item.contentType == "movie" and (item.infoLabels['tmdb_id'] or item.infoLabels['imdb_id'] or
                                                   item.contentTitle):
                 param = "id =%s,imdb_id=%s,name=%s" \
-                        % (item.infoLabels['tmdb_id'], item.infoLabels['imdb_id'], item.contentTitle)
+                       % (item.infoLabels['tmdb_id'], item.infoLabels['imdb_id'], item.contentTitle)
+
                 context_commands.append(("ExtendedInfo",
                                          "XBMC.RunScript(script.extendedinfo,info=extendedinfo,%s)" % param))
 
@@ -513,6 +524,14 @@ def set_context_commands(item, parent_item):
                                                                                    from_channel=item.channel,
 
                                                                                    contextual=True).tourl())))
+            if item.contentType == 'tvshow':
+                mediatype = 'tv'
+            else:
+                mediatype = item.contentType
+            context_commands.append(("[COLOR yellow]Buscar Similares[/COLOR]", "XBMC.Container.Update (%s?%s)" % (
+            sys.argv[0], item.clone(channel='search', action='discover_list', search_type='list', page='1',
+                                    list_type='%s/%s/similar' % (mediatype,item.infoLabels['tmdb_id'])).tourl())))
+
         # Definir como Pagina de inicio
         if config.get_setting('start_page'):
             if item.action not in ['findvideos', 'play']:
diff --git a/plugin.video.alfa/platformcode/unify.py b/plugin.video.alfa/platformcode/unify.py
index f50bb870..99e7bd64 100644
--- a/plugin.video.alfa/platformcode/unify.py
+++ b/plugin.video.alfa/platformcode/unify.py
@@ -140,6 +140,12 @@ def remove_format(string):
     #logger.debug('sale de remove: %s' % string)
     return string
 
+def normalize(string):
+    string = string.decode('utf-8')
+    normal = ''.join((c for c in unicodedata.normalize('NFD', unicode(string)) if unicodedata.category(c) != 'Mn'))
+    return normal
+
+
 def simplify(string):
 
     #logger.info()
@@ -148,9 +154,12 @@ def simplify(string):
     string = string.replace('-',' ').replace('_',' ')
     string = re.sub(r'\d+','', string)
     string = string.strip()
-    string = string.decode('utf-8')
-    notilde = ''.join((c for c in unicodedata.normalize('NFD', unicode(string)) if unicodedata.category(c) != 'Mn'))
-    string = notilde.decode()
+
+    notilde = normalize(string)
+    try:
+        string = notilde.decode()
+    except:
+        pass
     string = string.lower()
     #logger.debug('sale de simplify: %s' % string)
 
@@ -413,6 +422,14 @@ def title_format(item):
         if lang:
             item.title = add_languages(item.title, simple_language)
 
+        # Para las busquedas por canal
+        if item.from_channel != '':
+            from core import channeltools
+            channel_parameters = channeltools.get_channel_parameters(item.from_channel)
+            logger.debug(channel_parameters)
+            item.title = '%s [%s]' % (item.title, channel_parameters['title'])
+
+
         # Formato para actualizaciones de series en la videoteca sobreescribe los colores anteriores
 
         if item.channel=='videolibrary' and item.context!='':
diff --git a/plugin.video.alfa/resources/media/themes/default/thumb_genres.png b/plugin.video.alfa/resources/media/themes/default/thumb_genres.png
new file mode 100644
index 00000000..666ed4e4
Binary files /dev/null and b/plugin.video.alfa/resources/media/themes/default/thumb_genres.png differ
diff --git a/plugin.video.alfa/resources/media/themes/default/thumb_now_playing.png b/plugin.video.alfa/resources/media/themes/default/thumb_now_playing.png
new file mode 100644
index 00000000..c29f9c15
Binary files /dev/null and b/plugin.video.alfa/resources/media/themes/default/thumb_now_playing.png differ
diff --git a/plugin.video.alfa/resources/media/themes/default/thumb_on_the_air.png b/plugin.video.alfa/resources/media/themes/default/thumb_on_the_air.png
new file mode 100644
index 00000000..2d922977
Binary files /dev/null and b/plugin.video.alfa/resources/media/themes/default/thumb_on_the_air.png differ
diff --git a/plugin.video.alfa/resources/media/themes/default/thumb_popular.png b/plugin.video.alfa/resources/media/themes/default/thumb_popular.png
new file mode 100644
index 00000000..901a812a
Binary files /dev/null and b/plugin.video.alfa/resources/media/themes/default/thumb_popular.png differ
diff --git a/plugin.video.alfa/resources/media/themes/default/thumb_top_rated.png b/plugin.video.alfa/resources/media/themes/default/thumb_top_rated.png
new file mode 100644
index 00000000..5af93f6b
Binary files /dev/null and b/plugin.video.alfa/resources/media/themes/default/thumb_top_rated.png differ