diff --git a/client/public/index.html b/client/public/index.html
index 3528872..c4512ad 100644
--- a/client/public/index.html
+++ b/client/public/index.html
@@ -27,6 +27,7 @@
     <title>SeekTune</title>
   </head>
   <body>
+    <script src="/wasm_exec.js"></script>
     <noscript>You need to enable JavaScript to run this app.</noscript>
     <div id="root"></div>
     <!--
diff --git a/client/public/main.wasm b/client/public/main.wasm
new file mode 100755
index 0000000..34ccaac
Binary files /dev/null and b/client/public/main.wasm differ
diff --git a/client/public/wasm_exec.js b/client/public/wasm_exec.js
new file mode 100644
index 0000000..bc6f210
--- /dev/null
+++ b/client/public/wasm_exec.js
@@ -0,0 +1,561 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+"use strict";
+
+(() => {
+	const enosys = () => {
+		const err = new Error("not implemented");
+		err.code = "ENOSYS";
+		return err;
+	};
+
+	if (!globalThis.fs) {
+		let outputBuf = "";
+		globalThis.fs = {
+			constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused
+			writeSync(fd, buf) {
+				outputBuf += decoder.decode(buf);
+				const nl = outputBuf.lastIndexOf("\n");
+				if (nl != -1) {
+					console.log(outputBuf.substring(0, nl));
+					outputBuf = outputBuf.substring(nl + 1);
+				}
+				return buf.length;
+			},
+			write(fd, buf, offset, length, position, callback) {
+				if (offset !== 0 || length !== buf.length || position !== null) {
+					callback(enosys());
+					return;
+				}
+				const n = this.writeSync(fd, buf);
+				callback(null, n);
+			},
+			chmod(path, mode, callback) { callback(enosys()); },
+			chown(path, uid, gid, callback) { callback(enosys()); },
+			close(fd, callback) { callback(enosys()); },
+			fchmod(fd, mode, callback) { callback(enosys()); },
+			fchown(fd, uid, gid, callback) { callback(enosys()); },
+			fstat(fd, callback) { callback(enosys()); },
+			fsync(fd, callback) { callback(null); },
+			ftruncate(fd, length, callback) { callback(enosys()); },
+			lchown(path, uid, gid, callback) { callback(enosys()); },
+			link(path, link, callback) { callback(enosys()); },
+			lstat(path, callback) { callback(enosys()); },
+			mkdir(path, perm, callback) { callback(enosys()); },
+			open(path, flags, mode, callback) { callback(enosys()); },
+			read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
+			readdir(path, callback) { callback(enosys()); },
+			readlink(path, callback) { callback(enosys()); },
+			rename(from, to, callback) { callback(enosys()); },
+			rmdir(path, callback) { callback(enosys()); },
+			stat(path, callback) { callback(enosys()); },
+			symlink(path, link, callback) { callback(enosys()); },
+			truncate(path, length, callback) { callback(enosys()); },
+			unlink(path, callback) { callback(enosys()); },
+			utimes(path, atime, mtime, callback) { callback(enosys()); },
+		};
+	}
+
+	if (!globalThis.process) {
+		globalThis.process = {
+			getuid() { return -1; },
+			getgid() { return -1; },
+			geteuid() { return -1; },
+			getegid() { return -1; },
+			getgroups() { throw enosys(); },
+			pid: -1,
+			ppid: -1,
+			umask() { throw enosys(); },
+			cwd() { throw enosys(); },
+			chdir() { throw enosys(); },
+		}
+	}
+
+	if (!globalThis.crypto) {
+		throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
+	}
+
+	if (!globalThis.performance) {
+		throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
+	}
+
+	if (!globalThis.TextEncoder) {
+		throw new Error("globalThis.TextEncoder is not available, polyfill required");
+	}
+
+	if (!globalThis.TextDecoder) {
+		throw new Error("globalThis.TextDecoder is not available, polyfill required");
+	}
+
+	const encoder = new TextEncoder("utf-8");
+	const decoder = new TextDecoder("utf-8");
+
+	globalThis.Go = class {
+		constructor() {
+			this.argv = ["js"];
+			this.env = {};
+			this.exit = (code) => {
+				if (code !== 0) {
+					console.warn("exit code:", code);
+				}
+			};
+			this._exitPromise = new Promise((resolve) => {
+				this._resolveExitPromise = resolve;
+			});
+			this._pendingEvent = null;
+			this._scheduledTimeouts = new Map();
+			this._nextCallbackTimeoutID = 1;
+
+			const setInt64 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+				this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+			}
+
+			const setInt32 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+			}
+
+			const getInt64 = (addr) => {
+				const low = this.mem.getUint32(addr + 0, true);
+				const high = this.mem.getInt32(addr + 4, true);
+				return low + high * 4294967296;
+			}
+
+			const loadValue = (addr) => {
+				const f = this.mem.getFloat64(addr, true);
+				if (f === 0) {
+					return undefined;
+				}
+				if (!isNaN(f)) {
+					return f;
+				}
+
+				const id = this.mem.getUint32(addr, true);
+				return this._values[id];
+			}
+
+			const storeValue = (addr, v) => {
+				const nanHead = 0x7FF80000;
+
+				if (typeof v === "number" && v !== 0) {
+					if (isNaN(v)) {
+						this.mem.setUint32(addr + 4, nanHead, true);
+						this.mem.setUint32(addr, 0, true);
+						return;
+					}
+					this.mem.setFloat64(addr, v, true);
+					return;
+				}
+
+				if (v === undefined) {
+					this.mem.setFloat64(addr, 0, true);
+					return;
+				}
+
+				let id = this._ids.get(v);
+				if (id === undefined) {
+					id = this._idPool.pop();
+					if (id === undefined) {
+						id = this._values.length;
+					}
+					this._values[id] = v;
+					this._goRefCounts[id] = 0;
+					this._ids.set(v, id);
+				}
+				this._goRefCounts[id]++;
+				let typeFlag = 0;
+				switch (typeof v) {
+					case "object":
+						if (v !== null) {
+							typeFlag = 1;
+						}
+						break;
+					case "string":
+						typeFlag = 2;
+						break;
+					case "symbol":
+						typeFlag = 3;
+						break;
+					case "function":
+						typeFlag = 4;
+						break;
+				}
+				this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+				this.mem.setUint32(addr, id, true);
+			}
+
+			const loadSlice = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+			}
+
+			const loadSliceOfValues = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				const a = new Array(len);
+				for (let i = 0; i < len; i++) {
+					a[i] = loadValue(array + i * 8);
+				}
+				return a;
+			}
+
+			const loadString = (addr) => {
+				const saddr = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+			}
+
+			const timeOrigin = Date.now() - performance.now();
+			this.importObject = {
+				_gotest: {
+					add: (a, b) => a + b,
+				},
+				gojs: {
+					// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+					// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+					// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+					// This changes the SP, thus we have to update the SP used by the imported function.
+
+					// func wasmExit(code int32)
+					"runtime.wasmExit": (sp) => {
+						sp >>>= 0;
+						const code = this.mem.getInt32(sp + 8, true);
+						this.exited = true;
+						delete this._inst;
+						delete this._values;
+						delete this._goRefCounts;
+						delete this._ids;
+						delete this._idPool;
+						this.exit(code);
+					},
+
+					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+					"runtime.wasmWrite": (sp) => {
+						sp >>>= 0;
+						const fd = getInt64(sp + 8);
+						const p = getInt64(sp + 16);
+						const n = this.mem.getInt32(sp + 24, true);
+						fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+					},
+
+					// func resetMemoryDataView()
+					"runtime.resetMemoryDataView": (sp) => {
+						sp >>>= 0;
+						this.mem = new DataView(this._inst.exports.mem.buffer);
+					},
+
+					// func nanotime1() int64
+					"runtime.nanotime1": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
+					},
+
+					// func walltime() (sec int64, nsec int32)
+					"runtime.walltime": (sp) => {
+						sp >>>= 0;
+						const msec = (new Date).getTime();
+						setInt64(sp + 8, msec / 1000);
+						this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
+					},
+
+					// func scheduleTimeoutEvent(delay int64) int32
+					"runtime.scheduleTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this._nextCallbackTimeoutID;
+						this._nextCallbackTimeoutID++;
+						this._scheduledTimeouts.set(id, setTimeout(
+							() => {
+								this._resume();
+								while (this._scheduledTimeouts.has(id)) {
+									// for some reason Go failed to register the timeout event, log and try again
+									// (temporary workaround for https://github.com/golang/go/issues/28975)
+									console.warn("scheduleTimeoutEvent: missed timeout event");
+									this._resume();
+								}
+							},
+							getInt64(sp + 8),
+						));
+						this.mem.setInt32(sp + 16, id, true);
+					},
+
+					// func clearTimeoutEvent(id int32)
+					"runtime.clearTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getInt32(sp + 8, true);
+						clearTimeout(this._scheduledTimeouts.get(id));
+						this._scheduledTimeouts.delete(id);
+					},
+
+					// func getRandomData(r []byte)
+					"runtime.getRandomData": (sp) => {
+						sp >>>= 0;
+						crypto.getRandomValues(loadSlice(sp + 8));
+					},
+
+					// func finalizeRef(v ref)
+					"syscall/js.finalizeRef": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getUint32(sp + 8, true);
+						this._goRefCounts[id]--;
+						if (this._goRefCounts[id] === 0) {
+							const v = this._values[id];
+							this._values[id] = null;
+							this._ids.delete(v);
+							this._idPool.push(id);
+						}
+					},
+
+					// func stringVal(value string) ref
+					"syscall/js.stringVal": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, loadString(sp + 8));
+					},
+
+					// func valueGet(v ref, p string) ref
+					"syscall/js.valueGet": (sp) => {
+						sp >>>= 0;
+						const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+						sp = this._inst.exports.getsp() >>> 0; // see comment above
+						storeValue(sp + 32, result);
+					},
+
+					// func valueSet(v ref, p string, x ref)
+					"syscall/js.valueSet": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+					},
+
+					// func valueDelete(v ref, p string)
+					"syscall/js.valueDelete": (sp) => {
+						sp >>>= 0;
+						Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+					},
+
+					// func valueIndex(v ref, i int) ref
+					"syscall/js.valueIndex": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+					},
+
+					// valueSetIndex(v ref, i int, x ref)
+					"syscall/js.valueSetIndex": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+					},
+
+					// func valueCall(v ref, m string, args []ref) (ref, bool)
+					"syscall/js.valueCall": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const m = Reflect.get(v, loadString(sp + 16));
+							const args = loadSliceOfValues(sp + 32);
+							const result = Reflect.apply(m, v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, result);
+							this.mem.setUint8(sp + 64, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, err);
+							this.mem.setUint8(sp + 64, 0);
+						}
+					},
+
+					// func valueInvoke(v ref, args []ref) (ref, bool)
+					"syscall/js.valueInvoke": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.apply(v, undefined, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueNew(v ref, args []ref) (ref, bool)
+					"syscall/js.valueNew": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.construct(v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueLength(v ref) int
+					"syscall/js.valueLength": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+					},
+
+					// valuePrepareString(v ref) (ref, int)
+					"syscall/js.valuePrepareString": (sp) => {
+						sp >>>= 0;
+						const str = encoder.encode(String(loadValue(sp + 8)));
+						storeValue(sp + 16, str);
+						setInt64(sp + 24, str.length);
+					},
+
+					// valueLoadString(v ref, b []byte)
+					"syscall/js.valueLoadString": (sp) => {
+						sp >>>= 0;
+						const str = loadValue(sp + 8);
+						loadSlice(sp + 16).set(str);
+					},
+
+					// func valueInstanceOf(v ref, t ref) bool
+					"syscall/js.valueInstanceOf": (sp) => {
+						sp >>>= 0;
+						this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
+					},
+
+					// func copyBytesToGo(dst []byte, src ref) (int, bool)
+					"syscall/js.copyBytesToGo": (sp) => {
+						sp >>>= 0;
+						const dst = loadSlice(sp + 8);
+						const src = loadValue(sp + 32);
+						if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					// func copyBytesToJS(dst ref, src []byte) (int, bool)
+					"syscall/js.copyBytesToJS": (sp) => {
+						sp >>>= 0;
+						const dst = loadValue(sp + 8);
+						const src = loadSlice(sp + 16);
+						if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					"debug": (value) => {
+						console.log(value);
+					},
+				}
+			};
+		}
+
+		async run(instance) {
+			if (!(instance instanceof WebAssembly.Instance)) {
+				throw new Error("Go.run: WebAssembly.Instance expected");
+			}
+			this._inst = instance;
+			this.mem = new DataView(this._inst.exports.mem.buffer);
+			this._values = [ // JS values that Go currently has references to, indexed by reference id
+				NaN,
+				0,
+				null,
+				true,
+				false,
+				globalThis,
+				this,
+			];
+			this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
+			this._ids = new Map([ // mapping from JS values to reference ids
+				[0, 1],
+				[null, 2],
+				[true, 3],
+				[false, 4],
+				[globalThis, 5],
+				[this, 6],
+			]);
+			this._idPool = [];   // unused ids that have been garbage collected
+			this.exited = false; // whether the Go program has exited
+
+			// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
+			let offset = 4096;
+
+			const strPtr = (str) => {
+				const ptr = offset;
+				const bytes = encoder.encode(str + "\0");
+				new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+				offset += bytes.length;
+				if (offset % 8 !== 0) {
+					offset += 8 - (offset % 8);
+				}
+				return ptr;
+			};
+
+			const argc = this.argv.length;
+
+			const argvPtrs = [];
+			this.argv.forEach((arg) => {
+				argvPtrs.push(strPtr(arg));
+			});
+			argvPtrs.push(0);
+
+			const keys = Object.keys(this.env).sort();
+			keys.forEach((key) => {
+				argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+			});
+			argvPtrs.push(0);
+
+			const argv = offset;
+			argvPtrs.forEach((ptr) => {
+				this.mem.setUint32(offset, ptr, true);
+				this.mem.setUint32(offset + 4, 0, true);
+				offset += 8;
+			});
+
+			// The linker guarantees global data starts from at least wasmMinDataAddr.
+			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
+			const wasmMinDataAddr = 4096 + 8192;
+			if (offset >= wasmMinDataAddr) {
+				throw new Error("total length of command line and environment variables exceeds limit");
+			}
+
+			this._inst.exports.run(argc, argv);
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+			await this._exitPromise;
+		}
+
+		_resume() {
+			if (this.exited) {
+				throw new Error("Go program has already exited");
+			}
+			this._inst.exports.resume();
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+		}
+
+		_makeFuncWrapper(id) {
+			const go = this;
+			return function () {
+				const event = { id: id, this: this, args: arguments };
+				go._pendingEvent = event;
+				go._resume();
+				return event.result;
+			};
+		}
+	}
+})();
diff --git a/shazam/fft.go b/shazam/fft.go
index a3d3198..2fee6cb 100644
--- a/shazam/fft.go
+++ b/shazam/fft.go
@@ -4,20 +4,20 @@ import (
 	"math"
 )
 
-// Fft performs the Fast Fourier Transform on the input signal.
+// FFT computes the Fast Fourier Transform (FFT) of the input data,
+// converting the signal from the time domain to the frequency domain.
+// For better understanding, refer to this video: https://www.youtube.com/watch?v=spUNpyF58BY
 func FFT(input []float64) []complex128 {
-	// Convert input to complex128
 	complexArray := make([]complex128, len(input))
 	for i, v := range input {
 		complexArray[i] = complex(v, 0)
 	}
 
 	fftResult := make([]complex128, len(complexArray))
-	copy(fftResult, complexArray) // Copy input to result buffer
+	copy(fftResult, complexArray)
 	return recursiveFFT(fftResult)
 }
 
-// recursiveFFT performs the recursive FFT algorithm.
 func recursiveFFT(complexArray []complex128) []complex128 {
 	N := len(complexArray)
 	if N <= 1 {
diff --git a/shazam/filter.go b/shazam/filter.go
deleted file mode 100644
index d8b3db5..0000000
--- a/shazam/filter.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package shazam
-
-import (
-	"math"
-)
-
-// LowPassFilter is a first-order low-pass filter using H(p) = 1 / (1 + pRC)
-type LowPassFilter struct {
-	alpha float64 // Filter coefficient
-	yPrev float64 // Previous output value
-}
-
-// NewLowPassFilter creates a new low-pass filter
-func NewLowPassFilter(cutoffFrequency, sampleRate float64) *LowPassFilter {
-	rc := 1.0 / (2 * math.Pi * cutoffFrequency)
-	dt := 1.0 / sampleRate
-	alpha := dt / (rc + dt)
-	return &LowPassFilter{
-		alpha: alpha,
-		yPrev: 0,
-	}
-}
-
-// Filter processes the input signal through the low-pass filter
-func (lpf *LowPassFilter) Filter(input []float64) []float64 {
-	filtered := make([]float64, len(input))
-	for i, x := range input {
-		if i == 0 {
-			filtered[i] = x * lpf.alpha
-		} else {
-			filtered[i] = lpf.alpha*x + (1-lpf.alpha)*lpf.yPrev
-		}
-		lpf.yPrev = filtered[i]
-	}
-	return filtered
-}
diff --git a/shazam/fingerprint.go b/shazam/fingerprint.go
index 046cffd..a29398b 100644
--- a/shazam/fingerprint.go
+++ b/shazam/fingerprint.go
@@ -11,7 +11,6 @@ const (
 )
 
 // Fingerprint generates fingerprints from a list of peaks and stores them in an array.
-// The fingerprints are encoded using a 32-bit integer format and stored in an array.
 // Each fingerprint consists of an address and a couple.
 // The address is a hash. The couple contains the anchor time and the song ID.
 func Fingerprint(peaks []Peak, songID uint32) map[uint32]models.Couple {
diff --git a/shazam/image.go b/shazam/image.go
index fb87a22..0a758a2 100644
--- a/shazam/image.go
+++ b/shazam/image.go
@@ -11,11 +11,9 @@ import (
 
 // ConvertSpectrogramToImage converts a spectrogram to a heat map image
 func SpectrogramToImage(spectrogram [][]complex128, outputPath string) error {
-	// Determine dimensions of the spectrogram
 	numWindows := len(spectrogram)
 	numFreqBins := len(spectrogram[0])
 
-	// Create a new grayscale image
 	img := image.NewGray(image.Rect(0, 0, numFreqBins, numWindows))
 
 	// Scale the values in the spectrogram to the range [0, 255]
@@ -38,7 +36,6 @@ func SpectrogramToImage(spectrogram [][]complex128, outputPath string) error {
 		}
 	}
 
-	// Save the image to a PNG file
 	file, err := os.Create(outputPath)
 	if err != nil {
 		return err
diff --git a/shazam/shazam.go b/shazam/shazam.go
index a3e5f68..0683019 100644
--- a/shazam/shazam.go
+++ b/shazam/shazam.go
@@ -1,3 +1,6 @@
+//go:build !js && !wasm
+// +build !js,!wasm
+
 package shazam
 
 import (
@@ -18,21 +21,35 @@ type Match struct {
 	Score      float64
 }
 
-// FindMatches processes the audio samples and finds matches in the database
-func FindMatches(audioSamples []float64, audioDuration float64, sampleRate int) ([]Match, time.Duration, error) {
+// FindMatches analyzes the audio sample to find matching songs in the database.
+func FindMatches(audioSample []float64, audioDuration float64, sampleRate int) ([]Match, time.Duration, error) {
 	startTime := time.Now()
-	logger := utils.GetLogger()
 
-	spectrogram, err := Spectrogram(audioSamples, sampleRate)
+	spectrogram, err := Spectrogram(audioSample, sampleRate)
 	if err != nil {
 		return nil, time.Since(startTime), fmt.Errorf("failed to get spectrogram of samples: %v", err)
 	}
 
 	peaks := ExtractPeaks(spectrogram, audioDuration)
-	fingerprints := Fingerprint(peaks, utils.GenerateUniqueID())
+	sampleFingerprint := Fingerprint(peaks, utils.GenerateUniqueID())
 
-	addresses := make([]uint32, 0, len(fingerprints))
-	for address := range fingerprints {
+	sampleFingerprintMap := make(map[uint32]uint32)
+	for address, couple := range sampleFingerprint {
+		sampleFingerprintMap[address] = couple.AnchorTimeMs
+	}
+
+	matches, _, err := FindMatchesFGP(sampleFingerprintMap)
+
+	return matches, time.Since(startTime), nil
+}
+
+// FindMatchesFGP uses the sample fingerprint to find matching songs in the database.
+func FindMatchesFGP(sampleFingerprint map[uint32]uint32) ([]Match, time.Duration, error) {
+	startTime := time.Now()
+	logger := utils.GetLogger()
+
+	addresses := make([]uint32, 0, len(sampleFingerprint))
+	for address := range sampleFingerprint {
 		addresses = append(addresses, address)
 	}
 
@@ -47,19 +64,34 @@ func FindMatches(audioSamples []float64, audioDuration float64, sampleRate int)
 		return nil, time.Since(startTime), err
 	}
 
-	matches := map[uint32][][2]uint32{} // songID -> [(sampleTime, dbTime)]
-	timestamps := map[uint32][]uint32{}
+	matches := map[uint32][][2]uint32{}        // songID -> [(sampleTime, dbTime)]
+	timestamps := map[uint32]uint32{}          // songID -> earliest timestamp
+	targetZones := map[uint32]map[uint32]int{} // songID -> timestamp -> count
 
 	for address, couples := range m {
 		for _, couple := range couples {
-			matches[couple.SongID] = append(matches[couple.SongID], [2]uint32{fingerprints[address].AnchorTimeMs, couple.AnchorTimeMs})
-			timestamps[couple.SongID] = append(timestamps[couple.SongID], couple.AnchorTimeMs)
+			matches[couple.SongID] = append(
+				matches[couple.SongID],
+				[2]uint32{sampleFingerprint[address], couple.AnchorTimeMs},
+			)
+
+			if existingTime, ok := timestamps[couple.SongID]; !ok || couple.AnchorTimeMs < existingTime {
+				timestamps[couple.SongID] = couple.AnchorTimeMs
+			}
+
+			if _, ok := targetZones[couple.SongID]; !ok {
+				targetZones[couple.SongID] = make(map[uint32]int)
+			}
+			targetZones[couple.SongID][couple.AnchorTimeMs]++
 		}
 	}
 
+	// matches = filterMatches(10, matches, targetZones)
+
 	scores := analyzeRelativeTiming(matches)
 
 	var matchList []Match
+
 	for songID, points := range scores {
 		song, songExists, err := db.GetSongByID(songID)
 		if !songExists {
@@ -71,11 +103,7 @@ func FindMatches(audioSamples []float64, audioDuration float64, sampleRate int)
 			continue
 		}
 
-		sort.Slice(timestamps[songID], func(i, j int) bool {
-			return timestamps[songID][i] < timestamps[songID][j]
-		})
-
-		match := Match{songID, song.Title, song.Artist, song.YouTubeID, timestamps[songID][0], points}
+		match := Match{songID, song.Title, song.Artist, song.YouTubeID, timestamps[songID], points}
 		matchList = append(matchList, match)
 	}
 
@@ -86,7 +114,35 @@ func FindMatches(audioSamples []float64, audioDuration float64, sampleRate int)
 	return matchList, time.Since(startTime), nil
 }
 
-// AnalyzeRelativeTiming checks for consistent relative timing and returns a score
+// filterMatches filters out matches that don't have enough
+// target zones to meet the specified threshold
+func filterMatches(
+	threshold int,
+	matches map[uint32][][2]uint32,
+	targetZones map[uint32]map[uint32]int) map[uint32][][2]uint32 {
+
+	// Filter out non target zones.
+	// When a target zone has less than `targetZoneSize` anchor times, it is not considered a target zone.
+	for songID, anchorTimes := range targetZones {
+		for anchorTime, count := range anchorTimes {
+			if count < targetZoneSize {
+				delete(targetZones[songID], anchorTime)
+			}
+		}
+	}
+
+	filteredMatches := map[uint32][][2]uint32{}
+	for songID, zones := range targetZones {
+		if len(zones) >= threshold {
+			filteredMatches[songID] = matches[songID]
+		}
+	}
+
+	return filteredMatches
+}
+
+// analyzeRelativeTiming calculates a score for each song based on the
+// relative timing between the song and the sample's anchor times.
 func analyzeRelativeTiming(matches map[uint32][][2]uint32) map[uint32]float64 {
 	scores := make(map[uint32]float64)
 	for songID, times := range matches {
diff --git a/shazam/shazamInit.go b/shazam/shazamInit.go
deleted file mode 100644
index f162663..0000000
--- a/shazam/shazamInit.go
+++ /dev/null
@@ -1,136 +0,0 @@
-package shazam
-
-import (
-	"fmt"
-	"song-recognition/db"
-	"song-recognition/models"
-	"song-recognition/utils"
-	"sort"
-)
-
-type Match1 struct {
-	SongID     uint32
-	SongTitle  string
-	SongArtist string
-	YouTubeID  string
-	Timestamp  uint32
-	Coherency  float64
-}
-
-func Search(audioSamples []float64, audioDuration float64, sampleRate int) ([]Match1, error) {
-	spectrogram, err := Spectrogram(audioSamples, sampleRate)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get spectrogram of samples: %v", err)
-	}
-
-	peaks := ExtractPeaks(spectrogram, audioDuration)
-	fingerprints := Fingerprint(peaks, utils.GenerateUniqueID())
-
-	addresses := make([]uint32, 0, len(fingerprints))
-	for address, _ := range fingerprints {
-		addresses = append(addresses, address)
-	}
-
-	db, err := db.NewDBClient()
-	if err != nil {
-		return nil, err
-	}
-	defer db.Close()
-
-	couples, err := db.GetCouples(addresses)
-	if err != nil {
-		return nil, err
-	}
-
-	targetZones := targetZones(couples)
-	fmt.Println("TargetZones: ", targetZones)
-	matches := timeCoherency(fingerprints, targetZones)
-
-	var matchList []Match1
-	for songID, coherency := range matches {
-		song, songExists, err := db.GetSongByID(songID)
-		if err != nil || !songExists {
-			return nil, err
-		}
-
-		timestamp := targetZones[songID][0]
-		match := Match1{songID, song.Title, song.Artist, song.YouTubeID, timestamp, float64(coherency)}
-
-		matchList = append(matchList, match)
-	}
-
-	sort.Slice(matchList, func(i, j int) bool {
-		return matchList[i].Coherency > matchList[j].Coherency
-	})
-
-	return matchList, nil
-}
-
-func targetZones(m map[uint32][]models.Couple) map[uint32][]uint32 {
-	songs := make(map[uint32]map[uint32]int)
-
-	for _, couples := range m {
-		for _, couple := range couples {
-			if _, ok := songs[couple.SongID]; !ok {
-				songs[couple.SongID] = make(map[uint32]int)
-			}
-			songs[couple.SongID][couple.AnchorTimeMs]++
-		}
-	}
-	fmt.Println("couples: ", songs)
-
-	for songID, anchorTimes := range songs {
-		for msTime, count := range anchorTimes {
-			if count < 5 {
-				delete(songs[songID], msTime)
-			}
-		}
-	}
-	fmt.Println("anchorTimes: ", songs)
-
-	targetZones := make(map[uint32][]uint32)
-	for songID, anchorTimes := range songs {
-		for anchorTime, _ := range anchorTimes {
-			targetZones[songID] = append(targetZones[songID], anchorTime)
-		}
-	}
-
-	return targetZones
-}
-
-func timeCoherency(record map[uint32]models.Couple, songs map[uint32][]uint32) map[uint32]int {
-	// var threshold float64
-	matches := make(map[uint32]int)
-
-	for songID, songAnchorTimes := range songs {
-		deltas := make(map[float64]int)
-		for _, songAnchorTime := range songAnchorTimes {
-			for _, recordAnchor := range record {
-				recordAnchorTimeMs := float64(recordAnchor.AnchorTimeMs)
-				delta := recordAnchorTimeMs - float64(songAnchorTime)
-				deltas[delta]++
-			}
-		}
-
-		// Find the maximum number of time-coherent notes
-		var maxOccurrences int
-		for _, occurrences := range deltas {
-			if occurrences > maxOccurrences {
-				maxOccurrences = occurrences
-			}
-		}
-
-		matches[songID] = maxOccurrences
-	}
-
-	// Apply threshold for coherency
-	/**
-	for songID, coherency := range matches {
-		if float64(coherency) < threshold*float64(len(record)) {
-			delete(matches, songID) // Remove songs with insufficient coherency
-		}
-	}
-	*/
-
-	return matches
-}
diff --git a/shazam/spectrogram.go b/shazam/spectrogram.go
index 6f2ebc8..2488019 100644
--- a/shazam/spectrogram.go
+++ b/shazam/spectrogram.go
@@ -14,19 +14,17 @@ const (
 	hopSize     = freqBinSize / 32
 )
 
-func Spectrogram(samples []float64, sampleRate int) ([][]complex128, error) {
-	lpf := NewLowPassFilter(maxFreq, float64(sampleRate))
-	filteredSamples := lpf.Filter(samples)
+func Spectrogram(sample []float64, sampleRate int) ([][]complex128, error) {
+	filteredSample := LowPassFilter(maxFreq, float64(sampleRate), sample)
 
-	downsampledSamples, err := Downsample(filteredSamples, sampleRate, sampleRate/dspRatio)
+	downsampledSample, err := Downsample(filteredSample, sampleRate, sampleRate/dspRatio)
 	if err != nil {
-		return nil, fmt.Errorf("couldn't downsample audio samples: %v", err)
+		return nil, fmt.Errorf("couldn't downsample audio sample: %v", err)
 	}
 
-	numOfWindows := len(downsampledSamples) / (freqBinSize - hopSize)
+	numOfWindows := len(downsampledSample) / (freqBinSize - hopSize)
 	spectrogram := make([][]complex128, numOfWindows)
 
-	// Apply Hamming window function
 	window := make([]float64, freqBinSize)
 	for i := range window {
 		window[i] = 0.54 - 0.46*math.Cos(2*math.Pi*float64(i)/(float64(freqBinSize)-1))
@@ -36,12 +34,12 @@ func Spectrogram(samples []float64, sampleRate int) ([][]complex128, error) {
 	for i := 0; i < numOfWindows; i++ {
 		start := i * hopSize
 		end := start + freqBinSize
-		if end > len(downsampledSamples) {
-			end = len(downsampledSamples)
+		if end > len(downsampledSample) {
+			end = len(downsampledSample)
 		}
 
 		bin := make([]float64, freqBinSize)
-		copy(bin, downsampledSamples[start:end])
+		copy(bin, downsampledSample[start:end])
 
 		// Apply Hamming window
 		for j := range window {
@@ -54,6 +52,29 @@ func Spectrogram(samples []float64, sampleRate int) ([][]complex128, error) {
 	return spectrogram, nil
 }
 
+// LowPassFilter is a first-order low-pass filter that attenuates high
+// frequencies above the cutoffFrequency.
+// It uses the transfer function H(s) = 1 / (1 + sRC), where RC is the time constant.
+func LowPassFilter(cutoffFrequency, sampleRate float64, input []float64) []float64 {
+	rc := 1.0 / (2 * math.Pi * cutoffFrequency)
+	dt := 1.0 / sampleRate
+	alpha := dt / (rc + dt)
+
+	filteredSignal := make([]float64, len(input))
+	var prevOutput float64 = 0
+
+	for i, x := range input {
+		if i == 0 {
+			filteredSignal[i] = x * alpha
+		} else {
+
+			filteredSignal[i] = alpha*x + (1-alpha)*prevOutput
+		}
+		prevOutput = filteredSignal[i]
+	}
+	return filteredSignal
+}
+
 // Downsample downsamples the input audio from originalSampleRate to targetSampleRate
 func Downsample(input []float64, originalSampleRate, targetSampleRate int) ([]float64, error) {
 	if targetSampleRate <= 0 || originalSampleRate <= 0 {
diff --git a/wasm/wasm_main.go b/wasm/wasm_main.go
new file mode 100644
index 0000000..2afb489
--- /dev/null
+++ b/wasm/wasm_main.go
@@ -0,0 +1,64 @@
+//go:build js && wasm
+// +build js,wasm
+
+package main
+
+import (
+	"song-recognition/shazam"
+	"song-recognition/utils"
+	"syscall/js"
+)
+
+func generateFingerprint(this js.Value, args []js.Value) interface{} {
+	if len(args) < 2 {
+		return js.ValueOf(map[string]interface{}{
+			"error": 1,
+			"data":  "Expected audio array and sample rate",
+		})
+	}
+
+	if args[0].Type() != js.TypeObject || args[1].Type() != js.TypeNumber {
+		return js.ValueOf(map[string]interface{}{
+			"error": 2,
+			"data":  "Invalid argument types; Expected audio array and samplerate (type: int)",
+		})
+	}
+
+	inputArray := args[0]
+	sampleRate := args[1].Int()
+
+	audioData := make([]float64, inputArray.Length())
+	for i := 0; i < inputArray.Length(); i++ {
+		audioData[i] = inputArray.Index(i).Float()
+	}
+
+	spectrogram, err := shazam.Spectrogram(audioData, sampleRate)
+	if err != nil {
+		return js.ValueOf(map[string]interface{}{
+			"error": 3,
+			"data":  "Error generating spectrogram: " + err.Error(),
+		})
+	}
+
+	peaks := shazam.ExtractPeaks(spectrogram, float64(len(audioData)/sampleRate))
+	fingerprint := shazam.Fingerprint(peaks, utils.GenerateUniqueID())
+
+	fingerprintArray := []interface{}{}
+	for address, couple := range fingerprint {
+		entry := map[string]interface{}{
+			"address":    address,
+			"anchorTime": couple.AnchorTimeMs,
+		}
+		fingerprintArray = append(fingerprintArray, entry)
+	}
+
+	return js.ValueOf(map[string]interface{}{
+		"error": 0,
+		"data":  fingerprintArray,
+	})
+}
+
+func main() {
+	js.Global().Set("generateFingerprint", js.FuncOf(generateFingerprint))
+	select {}
+}
