A new sound language should be invented with syntax like this :

I honestly have to admit that inspiration comes from "POVRAY", wich can be
considered
as the visual equivalent of Csound...It is a raytracer that describes a 3D
scene the same way
Csound does with sound.

I think Csound lacks in clarity and structure. Disadvantages of Csound
structure :
-needs everything to be completed on one line
-absence of parentheses,brackets,vector-style modifications
-opcodes are too short abrieviated...
- blah-blah..
- blah...
- bl..
- b..
- ..
- ?


#include "fx.inc"  // includes fx.inc file wich contains several reverb and
chorus modules
#insert "stereo_441.hdr" //inserts ascii content of file "stereo_441.hdr"

#declare My_LFO  
lfo { sine<5,1>}
##declare

#declare My_Random_LFO
lfo { rnd {
              uniform   // "uniform" and "interpolation are keywords (see
manual for details)
              interpolation
              frequency <5> /* anything between "<" and ">" are interpreted
as vectors
                                       (see manual for the vector
dimensions) */
             }//rnd block
      }
##declare

#declare My_Beep
sound {   sine  {
                         amplitude 10000
                         basefreq  100
                         harmon 1, 0.5
                         harmon 2, 2
                        }
              
               amplitude {     // modifies sine{} amplitude
                                overall {
                                    attack   0.1
                                    decay    0.1
                                    sustain   2
                                    release   0.1
                                          } //overall

                            harmon { <1>  My_LFO }  // My_LFO controls
harmonic 1
                            
                           harmon { <2>	
                                        My_Random_LFO * 1.5    
//My_Random_LFO for harmonic 2
			   }	
                              
                               } // amplitude block
                                          
              frequency {
                             
                            harmon { <1> sine <20,5> }  //sine

                              } // frequency block
                 }// sound block
##declare

output {
 My_Beep {  start 0
                   duration 7
                   stereo <0.3,0.7>   // 30% left channel, 70% right
channel
                }   
          }
My_Beep { start 7
                 duration 7
                  stereo { pan{sine<1,2>}}
                }
}output block


                                             

OR we could invent a language wich only works on massive parallel
processing Supercomputers.
This kind of language could be of a ultra high level like :

#include "amplitud.inc" 
//this includes different amplitude sets for symphonies

sound 1{ 
            symphony {   // generate a complete symphony with 300
instruments
                              instruments 300
                              style 1    ( beethoven 0.1)  // 10% of
beethoven style
                              style 2    ( bach 0.9)         //  90% of
Bach style
                            }                                
            morph { 
                          style<1,2>  //morph from style 1 to style 2
                          melodic 0.3  // 30% morphing of melody
                          rythm    0.7  /* 70% morphing of rythm, so here
the morph will be more clear
                                                on the rythm */
                          time duration/2 //morph will be complete in
duration/2 seconds
                        }
}

output { 1
            amplitude Standard_Symphony  
            start 0
            duration 3600 //1-hour symphony
          }

// ---------------- end of symphony.mus -----------------------------------
     
                           



David.