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 a07e4d89..1452bbd6 100644
--- a/plugin.video.alfa/channels/search.py
+++ b/plugin.video.alfa/channels/search.py
@@ -27,33 +27,35 @@ def mainlist(item):
     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'))
+    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'))
+                          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'))
+                         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'))
+             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'))
+    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'))
+             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'))
+                         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'))
+                         search_type='list', list_type='tv/top_rated', thumbnail=get_thumb("top_rated.png")))
 
 
 
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 5fd5eff4..a90b3644 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/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