Alright,  I hummed and hawed too much about this.  I wrote a
trivial  sndfile ecl lisp snippet.  It's just one screen  of
lisp that's mostly one of the sndfile examples.  My dream is
that someone else could also try playing with it (as trivial
sound  making  goes).   So I will talk about   dependencies,
download  the lisp files, building it, and an example  synth
program which I will also inline here. 

I'm on openbsd,  so please divine this into your own package
manager: 

pkg_add ecl libsndfile mpv lynx

I am just  using system calls to mpv to play the notes,  and
lynx  to  download  the lisp.   Ecl is  the  compiler,   and
libsndfile   is libsndfile.   Now I'm going to use shell  to
download some text files (ecl lisp source) using lynx. 

```ksh
mkdir conspiracy # it's named conspiracy.
cd conspiracy
lynx gopher://gopher.club/0/users/screwtape/conspiracy/build.ecl -dump \
    > build.ecl
lynx gopher://gopher.club/0/users/screwtape/conspiracy/conspiracy.ecl \
    -dump > conspiracy.ecl
lynx gopher://gopher.club/0/users/screwtape/conspiracy/foo.syn \
    -dump > foo.syn # example
mkdir notes # note wavs will go into here.
``` 

At this juncture,  you should probably lay eyes on what's in
each  of those  files  so you know I'm not virusing  you ;p.
They're  not very big. For portability  there's no pledge or
unveil. 

```ksh
ecl --load build.ecl ## This builds an executable named sine
./sine --load foo.syn
```
foo.syn   is actually  just another  lisp file that uses the
conspiracy.ecl built into ./sine. 

The  mechanism,  which  sucks  and is slow but is  extremely
general   is  to  redefun  the  functions   #'left-fun   and
#'right-fun   (float)   ->   float  then  call  (my-get-note
"note-file-name"   float-duration)  ->  lambda that makes  a
system call to mpv to play the note. 

So a "syn" lisp (or just in ./sine's repl) is like

```foo.syn

(defun left-fun (float)
 (values (apply (make-sine  440) `(,float))))
(defun right-fun (float)
 (values (apply (make-sine 660) `(,float))))

(setq   *lambda-1*   (my-get-note   "test-note-1"      1.2))
(funcall *lambda-1*)

(defun left-fun (float)
 (values (apply (make-sine  110) `(,float))))
(defun right-fun (float)
 (values (apply (make-sine 55) `(,float))))

(setq   *lambda-2*   (my-get-note   "test-note-2"      3.6))
(funcall *lambda-2*)
(funcall *lambda-1*)
(funcall *lambda-2*)
```

(ecl) async repeating can be like

(setq *process*
 (mp:process-run-function 'example 
  (lambda ()
   (loop for x below 10 do (sleep 1) 
    do (funcall *lambda-2*)))))
(mp:process-join *process*)

But I don't want to complicate things more here.