There is one benchmark inside the interp package:

name    time/op
Run-16  3.51ms ± 0%

name    alloc/op
Run-16   157kB ± 1%

name    allocs/op
Run-16     876 ± 0%

It essentially benchmarks a small program with a mix of variables, commands, expansions, and external programs (i.e. cat):

echo a b c d
echo ./$foo_interp_missing/etc $(echo foo_interp_missing bar_interp_missing)
foo_interp_missing="bar_interp_missing"
x=y :
fn() {
	local a=b
	for i in 1 2 3; do
		echo $i | cat
	done
}
[[ $foo_interp_missing == bar_interp_missing ]] && fn
echo a{b,c}d *.go
let i=(2   3)

The summary is that the native Go bits of the interpreter are fast enough for its use cases so far. Right now, the slowest part of the shell by far is using os/exec to call separate programs like cat above; each one of those costs milliseconds, when the shell parsing and interpreting in Go is in the order of microseconds.

But also, the performance will heavily depend on your use case. If you only need to run a small shell script, then it's likely that this interpreter will be faster than Bash for you from Go, as you'll avoid having to call Bash as a separate program - thus saving milliseconds. If you need to run a very complex and long shell script, then it's entirely possible that shells like Bash might be faster, simply because they might have optimized some edge cases that we haven't yet. You should measure and compare for your use case :)