diff --git a/README.md b/README.md
new file mode 100644
index 0000000..918cb09
--- /dev/null
+++ b/README.md
@@ -0,0 +1,43 @@
+# mvc
+
+An MPD music visualizer, based on curses. It works by reading the fifo output of an MPD instance. 
+At the moment it performs a Fast Fourier Transform of the raw PCM data provided by MPD, but a beat detection is going to be implemented to gain more precision.
+
+## Requirements
+
+The fifo output of MPD needs to be enabled. To do so, simply place this in your mpd.conf:
+
+```
+audio_output {
+    type                    "fifo"
+	name                    "my_fifo"
+	path                    "/tmp/mpd.fifo"
+	format                  "44100:16:1"
+}
+```
+This is allowing MPD to create a file (the location is hardcoded right now so it must be /tmp/mpd.fifo) and write it with raw PCM data in realtime.
+Path and format variables MUST be the same displayed above.
+By reading that, mvc is able to compute a frequency spectrum of the current track played.
+
+## Building
+
+Makefile-based.  
+```
+make all
+```
+
+To install:
+```
+sudo make install
+```
+
+## Usage
+
+Simply run:
+
+```
+mvc
+```
+
+Note that an instance of MPD must be running for mvc to work, otherwise the fifo file doesn't exist.
+
diff --git a/fft.c b/fft.c
new file mode 100644
index 0000000..dc6989d
--- /dev/null
+++ b/fft.c
@@ -0,0 +1,136 @@
+#include "fft.h"
+/* if flag is EVEN (0), it takes only the even elements
+ * otherwise if flag is ODD (1) it takes only the odd ones
+ */
+cplx *split_array(cplx *a, int len, int flag)
+{
+	int i, cnt = 0;
+	cplx *ret = malloc((len/2)*sizeof(cplx));
+
+	for(i=0+flag; i<len; i=i+2){
+		ret[cnt] = a[i];
+		cnt++;
+	}
+	return ret;
+}
+
+/* recursively compute the fft on an array of complex numbers
+ * this algorithm involves splitting the array in two parts each recursion
+ * to be more efficient 
+ */
+cplx *_fast_ft(cplx *compArray, int len)
+{
+	cplx omegaN, omega;
+	cplx *evenA, *oddA, *transformedA;
+	int i;
+	
+	/*termination*/
+	if(len == 1){
+		return compArray;
+	}
+	
+	omega = 1;
+	omegaN = cexp(2*PI*I/len); //the fourier coefficient
+	
+	evenA = _fast_ft(split_array(compArray, len, EVEN), len/2);
+	oddA = _fast_ft(split_array(compArray, len, ODD), len/2);
+	
+	/*the final array*/
+	transformedA = malloc(len*sizeof(cplx));
+
+	for(i=0; i<(len/2); i++){
+		transformedA[i] = evenA[i] + omega*oddA[i];
+		transformedA[i+(len/2)] = evenA[i] - omega*oddA[i];
+		omega = omegaN*omega;
+	}
+	free(evenA);
+	free(oddA);
+	free(compArray);
+	return transformedA;
+}
+
+void
+print_components(cplx *a, int len)
+{
+	int i;
+	for(i=0; i<len; i++){
+		/*creal and cimag extract the real and imaginary parts of a[i]*/
+		fprintf(stdout, "%g, %g\n", creal(a[i]), cimag(a[i])); 
+	}
+	fprintf(stdout, "\n");
+}
+
+unsigned int
+amplitude(cplx c)
+{
+	double sq;
+	unsigned int res;
+	
+	/*compute amplitude*/
+	sq = sqrt(pow(creal(c), 2) + pow(cimag(c), 2));
+	res = round(20*log10(sq)); // dB scale
+	return res;
+}
+
+unsigned int* 
+fast_fft(int inLen, uint16_t *sig)
+{
+	int i;
+	cplx *inputComponents;
+	cplx *outputComponents;
+	unsigned int *fftSig;
+
+	if(inLen % 2 != 0){
+		fprintf(stderr, "Note that the length of the array MUST be a power of 2.");
+		exit(EXIT_FAILURE);
+	}
+	inputComponents = (cplx*)malloc((inLen)*sizeof(cplx));
+	
+	for(i=1; i<inLen; i++){
+		inputComponents[i] = sig[i];
+	}
+	
+	/*fprintf(stdout, "in:\n");*/
+	/*print_components(inputComponents, inLen);*/
+	
+	outputComponents = _fast_ft(inputComponents, inLen);
+	fftSig = calloc(inLen, sizeof(unsigned int));	
+	/*fprintf(stdout, "out:\n");*/
+	/*print_components(outputComponents, inLen);*/
+	for(i=0; i<inLen; i++){
+		fftSig[i] = amplitude(outputComponents[i]);
+	}
+
+	free(outputComponents);
+	
+	return fftSig;	
+}
+
+unsigned int* 
+average_signal(unsigned int *fftBuf, int inLen, int maxC, int *avgLen)
+{
+	unsigned int* fftAvg = malloc(inLen*sizeof(unsigned int));
+	int i, j, k=0;
+	unsigned int avg;
+
+	if(maxC < 200){
+		*avgLen = 128;
+	} else {
+		*avgLen = 256;
+	}
+	
+	for(i=0; i<inLen/2; i=i+(inLen/(2*(*avgLen)))){
+		avg = 0;
+		for(j=0; j<(inLen/(2*(*avgLen))); j++){
+			avg += fftBuf[i+j];  		
+		}
+		fftAvg[k] = avg/(inLen/(2*(*avgLen))) - 80;
+		k++;
+	}
+	return fftAvg;
+}
+
+
+
+
+
diff --git a/fft.h b/fft.h
new file mode 100644
index 0000000..b53c1df
--- /dev/null
+++ b/fft.h
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h> // malloc
+#include <math.h>
+#include <complex.h>
+#include <stdint.h>		// uint16_t
+
+#define PI acos(-1.0) // even if it is defined as M_PI in math.h, this is more precise computationally
+#define EVEN 0
+#define ODD 1
+
+typedef double complex cplx;
+
+cplx *split_array(cplx *a, int len, int flag);
+cplx *_fast_ft(cplx *compArray, int len);
+void print_components(cplx *a, int len);
+unsigned int amplitude(cplx c);
+unsigned int* fast_fft(int inLen, uint16_t *sig);
+unsigned int* average_signal(unsigned int *fftBuf, int inLen, int maxC, int *avgLen);
diff --git a/makefile b/makefile
new file mode 100644
index 0000000..cc33fd0
--- /dev/null
+++ b/makefile
@@ -0,0 +1,28 @@
+ALL = fft.c utils_curses.c music_visualizer.c 
+LOCPATH = ./bin
+INSTALLPATH = /usr/local
+LFLAGS =  -lm -lcurses
+DEBFLAGS = -g -Wall 
+NAME = mvc
+
+all:
+	mkdir -p $(LOCPATH)
+	gcc $(ALL) -o $(LOCPATH)/$(NAME) $(LFLAGS) 
+debug:
+	mkdir -p $(LOCPATH)/debug
+	gcc $(ALL) -o $(LOCPATH)/debug/$(NAME)_debug $(LFLAGS) $(DEBFLAGS)
+asan:
+	gcc $(ALL) -o $(LOCPATH)/debug/$(NAME)_debug_asan $(LFLAGS) $(DEBFLAGS) -fsanitize=address
+clean:
+	rm $(LOCPATH)/$(NAME)
+	rm $(LOCPATH)/debug/$(NAME)_debug
+distclean:
+	rm -r $(LOCPATH)
+install:
+	cp $(LOCPATH)/$(NAME) $(INSTALLPATH)/bin/$(NAME)
+uninstall:
+	rm $(INSTALLPATH)/bin/$(NAME)
+
+
+
+	
diff --git a/music_visualizer.c b/music_visualizer.c
new file mode 100644
index 0000000..2606c91
--- /dev/null
+++ b/music_visualizer.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stdlib.h>		// exit
+#include <unistd.h>		// read
+#include <sys/stat.h>	// open	
+#include <fcntl.h>		// open
+#include <stdint.h>		// uint16_t
+#include "fft.h"		// fast fourier transform
+#include "utils_curses.h"
+
+/*FREQ		44100*/
+#define N_SAMPLES 	1024
+/*FPS		FREQ/N_SAMPLES*/
+
+int
+main(int argc, char *argv[])
+{
+	int fifo, i;
+	WINDOW *mainwin;
+	int maxR, maxC, avgLen; //curses
+	uint16_t buf[N_SAMPLES];
+	unsigned int *fftBuf, *fftAvg;
+
+	fifo = open("/tmp/mpd.fifo", O_RDONLY);
+	
+	if((mainwin = curses_init()) == NULL){
+		exit(EXIT_FAILURE);
+	}
+	getmaxyx(stdscr, maxR, maxC);
+	color_set(2, NULL);
+	mvprintw(maxR/2, maxC/2, "%d %d\n", maxR, maxC);
+	refresh();
+	
+	while(read(fifo, (uint16_t*)buf, 2*N_SAMPLES) != 0){
+		
+		fftBuf = fast_fft(N_SAMPLES, (uint16_t*)buf);
+		fftAvg = average_signal(fftBuf, N_SAMPLES, maxC, &avgLen);	
+		free(fftBuf);
+
+		for(i=0; i<avgLen; i++){
+			print_col(i, fftAvg[i], maxR);
+		}
+		refresh();
+		clear();
+	}
+	close(fifo);
+	delwin(mainwin);
+	endwin();
+
+	return 0;
+
+}
diff --git a/utils_curses.c b/utils_curses.c
new file mode 100644
index 0000000..0ba47b9
--- /dev/null
+++ b/utils_curses.c
@@ -0,0 +1,42 @@
+#include "utils_curses.h"
+
+
+void
+init_color_pairs()
+{
+	if(has_colors()){
+		start_color();
+
+		init_pair(1, COLOR_RED,     COLOR_BLACK);
+		init_pair(2, COLOR_GREEN,   COLOR_BLACK);
+        init_pair(3, COLOR_YELLOW,  COLOR_BLACK);
+        init_pair(4, COLOR_BLUE,    COLOR_BLACK);
+        init_pair(5, COLOR_CYAN,    COLOR_BLACK);
+        init_pair(6, COLOR_MAGENTA, COLOR_BLACK);
+        init_pair(7, COLOR_WHITE,   COLOR_BLACK);		
+	}
+}
+
+WINDOW*
+curses_init()
+{
+	WINDOW *w;
+	if((w = initscr()) == NULL){ //initialize curses library on current screen
+		fprintf(stderr, "Error opening screen\n");
+		return NULL;
+	}
+	init_color_pairs();
+	return w;
+}
+
+void
+print_col(int col, int length, int maxR)
+{
+	int row, l;
+	 
+	l = maxR - length;
+	for(row=maxR; row>l; row--){
+		mvaddch(row, col, SHARP);
+	}
+}
+
diff --git a/utils_curses.h b/utils_curses.h
new file mode 100644
index 0000000..d7ee544
--- /dev/null
+++ b/utils_curses.h
@@ -0,0 +1,7 @@
+#include <curses.h>
+
+#define SHARP '#'
+
+void init_color_pairs();
+WINDOW* curses_init();
+void print_col(int col, int length, int maxR);