diff --git a/package/src/ExpressionExecutorCuda.jl b/package/src/ExpressionExecutorCuda.jl
index 939cd0c..17471b6 100644
--- a/package/src/ExpressionExecutorCuda.jl
+++ b/package/src/ExpressionExecutorCuda.jl
@@ -61,14 +61,13 @@ function evaluate_gpu(expressions::Vector{Expr}, X::Matrix{Float32}, p::Vector{V
 	@inbounds Threads.@threads for i in eachindex(expressions)
 		ex = ExpressionProcessing.expr_to_postfix(expressions[i])
 		ptxKernels[i] = Transpiler.transpile(ex, variableSetSize, largestParameterSetSize, numVariableSets, i-1, kernelName) # i-1 because julia is 1-based but PTX needs 0-based indexing
-		# compiledKernels[i] = Transpiler.CompileKernel(ptxKernel, kernelName)
 	end
 
-	results = Matrix{Float32}(undef, numVariableSets, length(exprs))
+	results = Matrix{Float32}(undef, numVariableSets, length(expressions))
 	for i in 1:repetitions # Simulate parameter tuning -> local search (X remains the same, p gets changed in small steps and must be performed sequentially, which it is with this impl)
 		# evaluate
 		# results = Transpiler.evaluate(exprs, variables, numVariableSets, variableSetSize, p)
-		results = Transpiler.evaluate(ptxKernels, variables, variableSetSize, p, kernelName)
+		results = Transpiler.evaluate(ptxKernels, variables, numVariableSets, p, kernelName)
 	end
 
 	return results
diff --git a/package/src/Transpiler.jl b/package/src/Transpiler.jl
index 101b698..abe7c77 100644
--- a/package/src/Transpiler.jl
+++ b/package/src/Transpiler.jl
@@ -33,20 +33,20 @@ function evaluate(expressions::Vector{ExpressionProcessing.PostfixType}, cudaVar
 end
 
 "
-A simplified version of the evaluate function. It takes a list of already compiled kernels to be executed. This should yield better performance, where the same expressions should be evaluated multiple times i.e. for parameter optimisation.
+A simplified version of the evaluate function. It takes a list of already transpiled kernels to be executed. This should yield better performance, where the same expressions should be evaluated multiple times i.e. for parameter optimisation.
 "
 function evaluate(kernels::Vector{String}, cudaVars::CuArray{Float32}, nrOfVariableSets::Integer, parameters::Vector{Vector{Float32}}, kernelName::String)::Matrix{Float32}
 
 	cudaParams = Utils.create_cuda_array(parameters, NaN32) # maybe make constant (see PerformanceTests.jl for more info)
 
 	# each expression has nr. of variable sets (nr. of columns of the variables) results and there are n expressions
-	cudaResults = CuArray{Float32}(undef, nrOfVariableSets, length(expressions))
+	cudaResults = CuArray{Float32}(undef, nrOfVariableSets, length(kernels))
 
 	threads = min(nrOfVariableSets, 256)
 	blocks = cld(nrOfVariableSets, threads)
 	
 	@inbounds Threads.@threads for i in eachindex(kernels)
-		compiledKernel = CompileKernel(kernel[i], kernelName)
+		compiledKernel = CompileKernel(kernels[i], kernelName)
 		cudacall(compiledKernel, (CuPtr{Float32},CuPtr{Float32},CuPtr{Float32}), cudaVars, cudaParams, cudaResults; threads=threads, blocks=blocks)
 	end