<div>SAMANTHA HUDSON - AOVE BLACK LABEL</div><div>Samantha Hudson se transforma en un animal salvaje dispuesto a dejar al público al borde del colapso en su nuevo show AOVE Black Label , uno de los eventos culturales más potentes y subversivos de la escena musical nacional.</div><div>SAMANTHA HUDSON publicó el pasado Mayo "AOVE", un EP en clave de electrónica que ha traído la cultura rave y el makineo de vuelta.Sonidos electrizantes, melodías pegadizas y bajos que retumban contundentes imponiéndose en la escena.</div><div><br></div><div>.</div><div>De este nuevo trabajo musical nace la gira "AOVE BLACK LABEL" un show aún más ambicioso si cabe y que sitúa a la artista en un momento de poder sonoro y escénico como nunca antes habíamos visto. Tras su exitoso estreno en la noche del SÓNAR 2023, Aove Black Label se anticipa como uno de los productos culturales más potentes y subversivos de la escena musical nacional.</div>