File: VERSIONS

package info (click to toggle)
chuck 1.5.5.5-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 41,056 kB
sloc: cpp: 123,473; ansic: 35,893; javascript: 2,111; yacc: 609; makefile: 457; python: 174; perl: 86
file content (4865 lines) | stat: -rw-r--r-- 220,140 bytes
------------------
ChucK VERSIONS log
------------------

1.5.5.5 (September 2025)
=======
--> "ChucK to School 2025" ChuGL v0.2.7 release!
============
ChuGL v0.2.7
============
(added) `GModel` for loading 3D asset models (currently supports OBJ)
(added) `GPolyhedron` and `PolyhedronGeometry` for builtin platonic solids
(added) `GG.bloom()` and `GG.bloomPass()` to streamline adding bloom to the default scene
(added) `GWindow.files()` to detect draggin+dropping files onto the screen (see basic/gwindow.ck example!)
(added) `Material.wireframe(int)` to easily toggle whether a mesh is rendered as a wireframe
(added) `Texture.save(string)` to save a GPU texture to a .png
(added) `Geometry.indexCount()` to control the number of indices drawn in an indexed draw
(added) `GWindow.droppedFiles()` to handle drag+dropping files onto the window
(added) new `GText` features
  - `GText.characters(int)` to control the number of characters rendered on a GText
  - `GText.width(int)` to set text wrap width
  - `GText.align(int)` to set left/center/right alignment
  - `GText.size(int)` to scale text size while respecting wrap and alignment
(added) `Material.wireframe(int)` to render meshes as wireframes
(added) "the Kunwoo Kim Collection" -- NEW interactive visualizers for teaching
  - education/additive-synthesis.ck
  - education/basic-filters.ck
  - education/granular-synthesis.ck
  - education/karplus-strong.ck
  - education/panning.ck
  - education/spectrum-interp.ck
  - education/thx-visual.ck
  - education/vocoder.ck
  - education/fm-synthesis.ck
(updated) examples:
  - basic/gmodel.ck (introducing GModel, an asset loading GGen)
  - basic/gtext.ck (added new GText features)
  - basic/gwindow.ck (added new GWindow features)
  - basic/ggen-primitives.ck (see new GPolyhedron)
  - basic/geo-and-mat.ck (see new PolyhedronGeometry)
(updated) all ChuGL examples have been updated, streamlined, and commented
  - https://chuck.stanford.edu/chugl/examples/
(added) external data files for specific examples:
  - https://chuck.stanford.edu/chugl/examples/data/
(fixed) major bugs addressed:
  - incorrect transparency sorting on scenes with a large number of materials
  - scene background color not affecting clearcolor, causing semi-transparent objects (e.g. GText) to render incorrectly



1.5.5.2 (July 2025)
=======
--> new ChuGL v0.2.6 (see ChuGL release notes below)
~~~~~
ChucK 1.5.5.2
=============
(fixed) windows MIDI support (which was previously broken in 1.5.5.1)
(fixed) examples/analysis/xsynth.ck (thanks Celeste Betancur & Andrew Zhu Aday)
    * now performs a proper multi-band cross-synthesis using the magnitude
      in each band of signl X to modulate the corresponding frequency bin
      in signal Y to produce output Z
(added) examples/analysis/xsynth.ck-stereo.ck same as above + stereo delay
(added) examples/machine/platform.ck -- get underlying OS name + system time
(added) Machine methods
    string Machine.os()
        get the underlying operating system name; possible values include 
        "mac", "linux", "windows", "web", "ios", "android", "unknown"
    float Machine.timeOfDay()
        returns the time in seconds since Epoch 1970-01-01 00:00:00 +0000 (UTC).
        The returned time has microsecond resolution
    vec2 Machine.timeOfDay2()
        identical to Machine.timeOfDay(), only the return value is a vec2
        where x is time in seconds, and y is fractional time in microseconds.
        y is guaranteed to be between 0 and 1,000,000. x + y yields the total
        time. Useful for situations needing less than 64-bit precision e.g., 
        floats in OSC are 32-bit and one must send the x and y values 
        separately -- otherwise a significant amount of timing resolution
        would be lost
============
ChuGL v0.2.6
============
(added) Transparency!! (alpha-blended and sorted back to front)
  - See examples/basic/transparency.ck
(added) Shadow Mapping (a basic first version)
  - Implemented shadow mapping for GDirLight and GSpotLight
    (GPointLight currently not supported)
  - See examples/deep/shadows.ck
(reworked) Render graph API
  - `RenderPass` is now the base class of `ScenePass` (which renderas a GScene
    to a target texture, formerly this was called `RenderPass`) and
    `ScreenPass` (which renders a full-screen quad, useful for post processing
    effects)
  - Added new `RenderPass` methods `.clear()`, `.scissor()`,
    `.scissorNormalized()`, `.viewport()` and `.viewportNormalized()` 
  - Added `ScenePass.msaa(int)` which can be used to toggle MSAA antialiasing
  - Add resolution, time, delta_time, frame_count, mouse state, and chuck VM
    sample rate info to shader #FRAME_UNIFORMS. Simplifies writing generative
    shaders in shadertoy-style.
(added) UI improvements:
  - Add `UI.knob(...)` widgets
  - Add `UI.image(...)` and `UI.imageButton(...)` methods, which allow adding
    ChuGL Textures to UI. 
(update) Textures
  - Changed `TextureDesc.mips()` semantics. Set to `true` to generate a full
    mip chain, set to `false` to not create any mips beyond level 0.
  - Add `TextureDesc.resizable`, `TextureDesc.widthRatio` and
    `TextureDesc.heightRatio` to create resizable textures, i.e. textures that
    change in dimensions relative to window resolution. (helpful to make your
    app robust against changing screen sizes)
  - Add `Texture.write(int ptr)` which copies data from a pointer from a
    separate ChuGin. Use with caution!
  - change default surface texture to be non-srgb, add `OutputPass.gamma()` to
    control whether or not to apply gamma correction. (this simplifies getting
    accurate colors in basic 2D scenes without complex lighting.
(updated) various bug fixes
  - fix `GGen.lookAt(vec3 pos)` bug when up vector and forward vectors were
    collinear.
  - added `GGen.lookAt(vec3 pos, vec3 up)` which takes a custom up vector.
  - fix `GText.defaultFont()` not setting custom font path correctly
  - fix segfault caused by sending large amount of data to `UI.plotLines()`
  - setting `TextureLoadDesc.gen_mips` to false no longer erroneously
    generates a mip chain
  - fix `UI.beginChild(...)` not properly returning a value
  - Add normal matrix to #DRAW_UNIFORMS shader include to enable correct
    calculations of normal vectors for Meshes with non-uniform scale
(added) GText: Add antialias method `GText.antialias()`
(added) New Examples
  - basic/transparency.ck
    how to use transparent materials
  - rendergraph/slime.ck
    slime mold simulation using compute passes!
  - deep/pokemon_cries.ck
    Gameboy APU emulator that synthesis all Gen I pokemon cries!
  - deep/shadows.ck
    shadowmapping for directional and spot lights!
(updated) Under the Hood
  - Large architecture refactor to use a rendergraph + gpu resource cache
    + sorted drawcall structs to organize and dispatch GPU commands.
  - Caching GPU resources (namely BindGroups and TextureViews) significantly
    improves performance and increases the maximum number of draw calls that
    can be issued each frame


1.5.5.1 (May 2025)
=======
(updated) the underlying MIDI implementation been updated 
    (updated RtMidi from 1.0.4 to 6.0.0 | thanks to @cviejo)
    this updates MIDI support, including:
    * (macOS) MIDI timecode is now sent when using MidiOut
    * (inux) JACK MIDI support
(fixed) chump (package manager, Windows)
    * now correctly unzips packages for package installation
    * (updated chump from 0.0.1 to 0.0.2)
(fixed) array.zero() now works properly with multi-dimensional arrays; previously
    it would zero out the top-level array elements (which are actually the next
    level of inner arrays, since multi-dimensional array in chuck are arrays of
    arrays of arrays...)
(fixed) -=> for vec2 -=> v (where v is a vec2) was incorrect and would lead to
    a crash
(fixed) LiSa.playPos reporting; addressed off-by-one error and made consistent
    reporting semantics for loop/no-loop/bi-dir
(updated) examples/array/array_zero.ck now includes example of using .zero() with
    multi-dimensional arrays (thanks to @terryzfeng for reporting this issue)
(developer) added c++ host example #5 to demonstrate adding language APIs
    to ChucK from a c++ host:
    src/host-examples/example-5-custom-api.cpp


1.5.5.0 (March 2025)
=======
(added) ChuMP: ChucK Manager of Packages! v0.0.1 (alpha)
    INTRODUCING ChuMP, the official ChucK package manager! ChuMP currently exists
    as a command-line interface tool (`chump`), which can be used to install,
    update, and manage ChucK components ranging from chugins to ChucK libraries
    to datesets. ChuMP also includes tools (e.g., Chumpinate) for creating new
    packages, which the ChucK community is heartily invited to do
      |
    Selected available packages at time of release
    ------------------------------------------
    run `chump list` to see a list of pacakges
    ------------------------------------------
      * smuck: a framework for symbolic music notation and playback in ChucK
        (see below)
      * FluidSynth: a UGen for loading and rendering FluidSynth soundfonts
      * Rave: a UGen to load and run RAVE (Realtime Audio Variational autoEncoder)
      * WarpBuf: a UGen for real-time and high-quality independent time-stretching
        and pitch shifting of audio files; also supports Ableton .asd files
      * Hydra: a wrapper around the python configuration framework Hydra
      * Line: a UGen envelope of arbitrary ramps (ala Max/PD's line~ object)
      * Patch: a tool for update control values from UGens
      * PlinkyRev: a stereo reverb UGen; port of the Plinky synth's reverb
      * Rec: helper functions for recording to audio files. Supports recording
        from dac, ugens, and arrays of ugens
      * (many more packages are on the way!)
    -------------------------------------------
      * Chumpinate: two classes (Package & PackageVersion) to help create
        new packages for distribution using ChuMP
    -------------------------------------------
      |
    For more information, please visit:
    ---------------------------------
    https://chuck.stanford.edu/chump/
    ---------------------------------
(added) SMucK: Symoblic Music in ChucK! v0.1.0 (alpha)
      |
    INTRODUCING SMucK, a framework for writing, processing, and playback of symbolic
    music in ChucK.
      |
    to install (using ChuMP):
    -----------------------
    > `chump install smuck`
    -----------------------
      |
    to start using from ChucK code:
    ---------------
    @import "smuck"
    ---------------
      |
    for tutorials, examples, and documentation:
    ---------------------------------
    https://chuck.stanford.edu/smuck/
    ---------------------------------
(reworked) basic @doc functionality for language-defined classes to add
    inline CKDoc documentation for class definitions and function defintions.
(reworked; now different from 1.5.4.4) @doc now appears *before* the entity
    to be documented; now @doc can be also used with class variables
    ----------------------------------------
    // add inline documenation (processed at compile-time)
    @doc "this is a description for the class Foo"
    class Foo
    {
        // add inline documenation (processed at compile-time)
        @doc "a function in Foo, bar() likes calling his friends"
        fun void bar()
        { }

        // add inline documentation for a class variable
        @doc "this here is a variable called varFoo"
        5 => int varFoo;
    }
    // these @doc information will appear wherever CKDoc is generated
    // or displayed, for example:
    Foo.help();
    ----------------------------------------
(added) the ability to hide variables and functions in ckdoc by adding
    "(hidden)" in the @doc string, for example:
    ----------------------------------------
    @doc "putting (hidden) anywhere in the doc string hides the next thing"
    15 => int varBarHidden;
    ----------------------------------------
(added) examples/basic/blit4.ck
(added) ChAI: PCA reduce function call input dimension check
(added) ChAI: SVM predict function call input dimension check
(added) KNN nearest neighbor function call input value check
(fixed) @import issue that can result in certain entries in import path
    to be skipped over.
(fixed) @import issue resulting from inconsistent casing in filepaths
(fixed) an issue with the record-to-WAV-file examples:
    `rec-auto.ck` and `rec-auto-stereo.ck` where they would output an
    empty WAV file when trying to record (FYI this was caused by a
    combination of changes to UGen garbage collection since 1.5.4.2
    and neglecting to remove the temporary workaround in these example files)
(developer) chugins API now supports querying for the local install path
    of a chugin, using: QUERY->getinfo(QUERY, CHUGIN_INFO_INSTALL_DIR);
    NOTE: this requires updated chugin.h header (1.5.4.5 or higher) and
    the latest chuck host (1.5.4.5 or higher)


1.5.4.5 (March 2025)
=======
NOTE: 1.5.4.5 is identical to 1.5.5.0 but without ChuMP


1.5.4.4 (January 2025)
=======
(added) basic @doc functionality for language-defined classes to add inline
    CKDoc documentation for class definitions and function defintions.
(added, experimental -- NOTE: the semantics of this was rewored in 1.5.4.5)
    function to retrive CKDoc descriptions for classes and functions:
    string CKDoc.describe( Object target );
    ----------------------------------------
    class Foo
    {
        // add inline documenation (processed at compile-time)
        @doc "this is a description for the class Foo"

        fun void bar()
        {
            // add inline documenation (processed at compile-time)
            @doc "a function in Foo, bar() likes calling his friends"
        }
    }
    // print class description
    CKDoc.describe( Foo );
    // with an instance, can also get info about instanced functions
    Foo f;
    <<< CKDoc.describe( f ) >>>;
    <<< CKDoc.describe( f.bar ) >>>;
    ----------------------------------------
(fixed) proper emission of classes by name, e.g., `<<< SinOsc >>>;`
(fixed) attempts to assign to a constant right-hand-side variable
    e.g., `null @=> SinOsc;` now results in a compiler error
    NOTE: in the above example, SinOsc is a variable of type 'Type'
    and is created alongside the SinOsc class/type; such Type variables
    associated with class definitions are automatically marked as constant
(fixed) crash due to functions / classes references a local variable defined
    at file-scope; code emission is now internally re-ordered to compile
    file-scope code segments -> function definitions -> class definitions
(fixed) foreach `auto` variable typing for multi-dimenion array, e.g.,
    --------
    // two dim array
    for( auto x : [[1,2],[3,4]] ) {
        for( auto y : x ) {
            // print
            <<< y >>>;
        }
    }
    --------
=======
(fixed) miniAudicle export and record functionalities; these resulted in
    empty WAV file (in 1.5.4.2 and 1.5.4.3), due to updates to garbage collection
    policy for UGens. exporting and recording should now work, once again


1.5.4.3 (December 2024)
=======
new ChuGL v0.2.5 (see ChuGL release notes below)
~~~
ChucK 1.5.4.3
=======
(added, at last) class STATIC variable initialization for primitive
    and Objects types. (Previously, static variables needed to be
    instantiated and initialized separately.) Now variables of any
    type can be declared as static variable and they will be automatically
    initialized on a per-class basis. Example:
    ----------------------------------------
    class Foo
    {
        // declare a static int in class Foo
        5 => static int THE_NUM;
        // declare a static SinOsc in class Foo
        static SinOsc THE_UGEN(440);
    }
    // can be accessed as before
    <<< Foo.THE_NUM, Foo.THE_UGEN.freq() >>>;
    ----------------------------------------
    SEMANTICS for static variables
    ----------------------------------------
    as before, static variable can only be DECLARED:
    a) within a class definition
    b) outside of any class function defintion
    c) at the outer-most class scope (cannot be in nested { })
    -----------------------------------------
    COMPILE-TIME checks:
    1) a statement containing a static variable declaration
       CANNOT access member data/functions
    2) otherwise, a statement can access both static and member data.
    3) a statement containing a static variable declaration
       CANNOT access local (i.e., outside of class def) vars or funcs
       even in non-public classes
    -----------------------------------------
    RUNTIME checks:
    4) static initialization statements are run in immediate mode
       meaning no time advances; this is enforced at runtime; any
       time advances, including waiting on events, will result in
       a runtime exception
    -----------------------------------------
(added) examples/class/static-init.ck
        examples/import/import-test-3.ck
(added) '/usr/lib/chuck' to @import system search paths on Linux and MacOS.
    .chug files in system paths will auto-load on start up (.ck files will 
    not auto-load and needs to be @imported in order to be used); also 
    @import will now include this directory when resolving fileanems.
(added) "ChucK => Music Programming Language" title to --about
(fixed) object instantiation refcount integrity; now correctly accounts
    for the situation where the object reference count is 0 during
    constructors (before assignment to a variable) and the constructor
    performs operations that previously could cause itself to be garbage
    collected
(fixed) now properly emits function calls vs. function values
(fixed) class definitions that encounter compiler errors (or are
    in files that have compiler errors) are now correctly rolled back
    in the type system; previously it was possible to instantiate
    partial class definition defined in previously compiled code/file,
    with undefined outcome
=======
ChuGL v0.2.5 Release Notes
=======
(added) input functions to get *all* keys held/pressed/released this frame
    GWindow.keys()
    GWindow.keysDown()
    GWindow.keysUp()
(added) new RenderPass methods to set the output resolution, msaa sample 
    count,target scene and target camera for rendering garbage collection
    mechanism for all UGens(added) HUD pass to ChuGL's default rendergraph.
    Can now easily add 2d HUD overlay to 3D scenes by grucking ggens to
    GG.hud()
(added) examples/basic/hud.ck
(fixed) crash caused by ShaderDesc and other internal reference counting
    logic
=======


1.5.4.2 (November 2024)
=======
new ChuGL v0.2.4 (see ChuGL release notes below)
=======
(updated) --chugin-path:<path> no longer auto-loads chugins found in the 
    specified paths; instead the specified paths are added to the import 
    system user paths, and the .chug and .ck files within the specified 
    paths can be @imported.
(updated) improved internal garbage collection mechanism for all UGens; 
    now UGens are garbage collected and disconnected from all its UGen 
    connections, as soon as it is now longer referenced from code (previously,
    this was deferred until the end of origin shred the UGen was created on,
    which poses potentially significant memory build-up if a shred repeatedly
    instantiated/connected UGens without exiting). Overall, this internal
    update should result in improved CPU performance and memory behavior in 
    various scenarios.
(fixed) long-standing SndBuf issue, especially prevalent on macOS:
    "System error : Too many open files." this was due a combination of 
(fixed) memory leak involving string operations (e.g., string + string);
    internally, string operations now are appropriately handled by the
    operator overloading mechanism
(fixed) < <= > >= operators for strings
(fixed) an issue chugin system auto-load and --chugin-probe was skipping
    over the first element when scanning directories 
(fixed) vec2/vec3/vec4 implicit cast logic for +=> and -=> operations
    (previously, this would cause a crash in some cases)
(fixed) vec2/vec3/vec4 function call from literal (non-variable) value
    (e.g., @(1,0).magnitude(); previously this yielded a compiler error)
(added) examples/stk/tubebell-algo5.ck
(added) vector dot product methods for vec2, vec3, and vec4
        float vec2.dot( vec2 rhs )
        float vec3.dot( vec3 rhs )
        float vec4.dot( vec4 rhs )
(added) vector cross product method for vec3 and vec4 (as 3D shorthand)
    NOTE: this is the same as vec3*vec3 or vec4*vec4
    NOTE: 4D cross product is mathematically undefined; vec4 cross product
        ignores the `w` components and computes a 3D cross product;
        `w` is also set to zero in the resulting vec4
        vec3 vec3.cross( vec3 rhs )
        vec4 vec4.cross( vec4 rhs )
(added) Type.of( vec2 ) function to get the associate Type
(added) --auto-load-chugin-path:<path> flag -- this behaves as 
    --chugin-path previously did: chugins in the specified path(s) are 
    auto-loaded; .ck files can be @imported
(fixed) --chugin:<name> and --chugin-path:<path> now correctly auto-expand
    paths
(updated) Shred(.parent(), .ancester(), .childMemSize(), .childRegSize())
    now will operate with respect to the shred reference rather than always
    w.r.t. the calling shred (e.g., shred that is running when these functions
    are called)
(added) Shred.pc(), .regSP(), .memSP() -- for debugging, info, amusement
=======
ChuGL v0.2.4 Release Notes
=======
New Features:
- Should now support both X11 and Wayland on Linux
- PolygonGeometry: provides (decently) robust/performant triangulation, useful for animating or 
drawing deformable 2d shapes
- WireframeMaterial: renders a mesh as a wireframe
- Texture.copy(...): can now copy data between textures
- Texture.read(...): read back texture data from GPU --> CPU
~~~
Improvements:
- Significantly reduced startup time from loading large OBJ models or building geometry with 
many vertices (tangent frame calculation has been moved from the CPU --> GPU)
- Optimized webcam implementation (now consumes less memory and requires fewer memory transfers)
~~~
New examples
- deep/ray_triangle_intersection.ck: 3d ray-triangle intersection testing. Thanks Shenran!!
- deep/fish.ck: procedurally animating a fish, showcases PolygonGeometry
- deep/webcam_echo.ck: webcam delay effect via texture copying
- basic/triangulate.ck: polygon triangulation with PolygonGeometry
- basic/texture_read.ck: showcases reading texture data from GPU into chuck
~~~
Bug Fixes:
- Crash when using Video textures
- Fix race condition in Webcam destructor
- GText now supports empty strings, and can properly disconnect from the scenegraph
- AssLoader will take model ambient color (Ka) into account
=======


1.5.4.1 (November 2024)
=======
(patch release)
- (fixed, linux) a crash when the OTF handles an OTF command (add or replace)
- (added) support for crawling subdirectories for importing for packages
    to be managed by the upcoming ChuMP (ChucK Manager of Packages)
- (updated) --chugin-probe now prints .ck files in the import search paths
    NOTE: as of 1.5.4.1 chuck auto-loads ONLY chugins in the system search
    paths; all other chugins and all chuck files in the import search paths
    must be @imported in order to be used.


1.5.4.0 (November 2024)
=======
\/\/\/\/\/
LICENSE UPDATE: ChucK source code is dual-licensed under the MIT License 
and the GNU General Public License 2.0 (or any later version). You can 
choose either license in order to use the source code. Previoiusly, ChucK 
was GPL-only. Please the LICENSE.MIT and LICENSE.GPL in the source 
distribution for details.
----
NOTE: as before, miniAudicle source code remains GPL for now; chugins 
each have their own license(s). WebChucK, ChuGL, Chunity, Chunreal 
respectively have MIT licenses
/\/\/\/\/\
********** new language feature ************
@import system for .ck and .chug files
********************************************
- for language specification and examples regarding @import:
  ***************************************************
  https://chuck.stanford.edu/doc/language/import.html
  ***************************************************
- the @import system imports classes and operator overloads from another 
    .ck file, or from a chugin; it is designed to faciliate creating, 
    using, and distributing multi-file programs and libraries
- @import SYNTAX:
    @import "Foo.ck" // import Foo.ck
    @import "Bar.chug" // import Bar.chug chugin
    @import { "AAA.ck", "BBB.chug", "CCC" } // multiple imports on one line
    @import "/Users/ge/chuck/examples/import/foo-user.ck" // absolute path
    @import "../dir/Blarg.ck" // relative path
    @import "Foo" // can use implicit filename; @import will search and 
      match for .ck, .chug, and .chug.wasm, in each directory in the 
      chugin/import search paths
- @import picks up all (and only) *public* definitions (classes and 
    operator overloads);
    -- this implies that @import will only add new definitions to the type 
       system, but will NEVER automatically run any code; client code must 
       first instantiate class or use an operator to execute the contents 
       of imported files
    -- this makes it possible to write unit-test code for public classes 
       in the same file in which it is defined; any code outside of public 
       class/operator definition will NOT be type-checked or run (this 
       code will only scanned for syntax)
- @imports are resolved at compile-time, before the rest of the host file
    is evaluated; this makes it possible for a a host .ck file to @import 
    one or more files and make use of their contents immediately (when it 
    comes to dependency management, this compile-time import mechanism is 
    more powerful than the run-time Machine.add()).
- @import can work recursively; can @import files that @import other 
    files
- @import has built-in cycle-detection; if an @import cycle is detected, 
    a compiler error will be issued and that compilation will be failed 
*******************
ChuGL 0.2.3 Release
*******************
- Video textures! 
  - Currently supporting MPEG1 Video decoding and playback
- Webcam/video camera integration
- ChuGL can now run at a fixed framerate across all machines/monitors
  - `GG.fps(int fps)` to set the target framerate (lower values improve 
    chuck's audio performance)
  - defaults to 60fps
- Added skybox support to GScene and environment lighting to PhongMaterial
- New Examples
  - basic/skybox.ck
  - basic/webcam.ck
  - basic/video.ck
- Fix memory leak on creating new Shaders
- (updated behavior) the one-public-class-per-file restriction has been 
    lifted; i.e., it is now possible to define more than one public class 
    in a single .ck file; this update is intended to give programmers and 
    library creators more flexibility in organizing their public class 
    definiition
- (updated behavior) .ck files found in chugin/import search paths (e.g., 
    ~/.chuck/lib) NO LONGER automatically loads; instead these now must 
    be explicitly @imported to be used (FYI just the file name will 
    suffice, assuming there are no filename conflicts elsewhere in the 
    import paths)
*******************
- (added) member function in Object to get the instantiated type of an
    object, regardless of the apparent type
    Type Object.typeOfInstance()
        Get the instanced type of this object.
- (fixed) specific internal UGen connection error now handled without 
    exiting
- (fixed, windows) single letter filenames without extensions (e.g., "A") 
    now are distinguished from windows drive letters (e.g., "A:\")
- (fixed) Type.of() now reports more specific array type (e.g., 
    `string[]`) instead ofgeneric `@array`
- (fixed) type system [user] namespace now instantiated correctly at
    initialization; previously [global] was used until a clearVM was 
    performed -- this caused incorrect behavior with certain functionality,
    including a crash in Type.children(); relatedly a long-standing
    bug was fixed in the type system scope::lookup mechanism that added
    NULL entries during lookup
- (fixed) modulo `%` by zero (int or float) now throws an exception; 
    previously this would either produce an incorrect result or cause a 
    crash
- (updated) .sort() a string array will now sort alphabetically (instead 
    of by Object refs)
- (updated, internal) dynamic array types are now cached and reused,
    preventing potential memory build-up across compilations
- (updated) chugin probe no longer recursively crawl directories
- (updated) variable dependency check now treats sporked functions same 
    as function calls; unfulfilled dependencies will result in a compiler 
    error; previously, correctness in this regard was left to the 
    programmer but could cause a crash. this update is more stringent than 
    is always necessary (due to spork being parallel and the timing 
    behavior, the dependency sometimes are resolved in actuality. 
    however, ChucK team deems potentially over-aggressive dependency 
    checking  for sporked functions is preferrable to unexpected and 
    hard-to-debug crashes.
============
For example:
============
```
// spork a function (that depends on foo)
spork ~ printArray();

// initialize foo
5 => int foo;

// function that needs foo
fun void printArray()
{
    // need 'foo' initialized here
    if( foo == 5 ) <<< "success" >>>;
}

// give the sporked shred a chance to run
me.yield();
```
===============
compiler error:
===============
error: sporking 'printArray()' at this point potentially skips 
initialization of a needed variable:

  [9] spork ~ printArray();
              ^
error: ...(note: this skipped variable initialization is needed by 'fun 
void printArray()')

  [12] 5 => int foo;
                ^
error: ...(note: this is where the variable is used within 'fun void 
printArray()' or its subsidiaries)

  [18]     if( foo == 5 ) <<< "success" >>>;
               ^
...(hint: try calling 'printArray()' after the variable initialization)
==============


1.5.3.2 (October 2024)
=======
*** ChuGL maintanance patch ***
- (updated) backend WebGPU version to wgpu-22.1.0.5
- (added) OpenGL fallback on machines where modern graphics APIs (vulkan, metal, direct3d)
    are not supported
- (fixed) shreds can now exit a GG.nextFrame() loop without hanging the window
- (added) GG.unregisterShred() to manually unregister a graphics shred
- (added) new examples
  - deep/particles.ck : musical partical system
  - deep/sprite_animation.ck : sprite animation via sprite sheets
- (fixed) race condition on window resize
*******************************
- (added) MidiFileIn.bpm()
    "Same as beatsPerMinute()."
- (added) MidiFileIn.ticksPerQuarter();
    "Get the ticks per quarter (TPQ) value from the MIDI file header."
- (added) MidiFileIn.tpq();
    "Same as ticksPerQuarter()."
- (fixed) documentation for MidiMsg.when:
    "Duration since the last MidiMsg (only valid for MidiFileIn)."
- (fixed, windows) SndBuf issue when compiled with UNICODE (FYI SndBuf is still ANSI,
    but this averts an error due to char width mismatch)
- (changed, developer) chuck global manager getGlobalUGenSamples() now handles multi-channel
    implications for Chunity support for stereo
- (added) new examples (FM Synthesis)
    examples/stk/jacobass-algo1.ck
      (such groove, much Algorithm 1)
    examples/stk/nylon-guitar-algo1.ck
      (updated/renamed from honkeytonk-algo3.ck)


1.5.3.1 (October 2024)
=======
*** ChuGL maintanance patch ***
- (fixed) crash caused by calling UI functions before calling GG.nextFrame();
    now prints a warning with a hint to call GG.nextFrame()
- (fixed) CPU and memory spikes when minimizing a ChuGL window
- (fixed) crash caused by immediately disconnecting GGen after -->
*******************************
- (fixed) ADSR constructors now work correctly
- (fixed) compiler now reports line numbers and caret position correctly after
    a multi-line string literal


1.5.3.0 (September 2024)
=======
- (major update) ****** ChuGL.chug v0.2.0 (alpha) ******
    * complete under-the-hood engine rewrite
    * now uses WebGPU instead of OpenGL as the core graphic library
    * some minor API changes, see: https://chuck.stanford.edu/chugl/api/
    * new and updated examples, see: https://chuck.stanford.edu/chugl/examples/
    * for more information, visit: https://chuck.stanford.edu/chugl/
  *********************************************
- (added, macOS and Linux) --chugin: and --chugin-path:
    flags now expands '~' in filepath
- (developer) fixed QUERY->getinfo(); previously the function pointer was
    NULL and would caused a crash if called
- (developer) updated set/getParam() key names:
  was: CHUCK_PARAM_USER_CHUGINS now: CHUCK_PARAM_CHUGIN_LIST_USER
  was: CHUCK_PARAM_USER_CHUGIN_DIRECTORIES now: CHUCK_PARAM_CHUGIN_LIST_USER_DIR


1.5.2.5 (July 2024)
=======
- (updated) chugin API version from 10.1 to 10.2
- (added) chugin API for callback on shutdown
- (added) chugin API for setting array elements (thanks azaday)
- (added) overloaded constructors (more to come) 
==================
    Envelope( dur durationToTarget )
        Construct an Envelope with duration to reach target (assumed to be 1.0);
        FYI this does not start the Envelope until .keyOn() is called.
    Envelope( float secondsToTarget )
        Construct an Envelope with duration (in seconds) to reach target (assumed to be 1.0);
        FYI this does not start the Envelope until .keyOn() is called.
    Envelope( dur durationToTarget, float target )
        Construct an Envelope with duration to reach target;
        FYI this does not start the Envelope until .keyOn() is called.
    Envelope( float durationToTarget, float target )
        Construct an Envelope with duration (in seconds) to reach target;
        FYI this does not start the Envelope until .keyOn() is called.

    ADSR( dur attack, dur decay, float sustain, dur release )
        Construct an ADSR with attack, decay, sustain, and release values. Attack, 
        decay, and release values are durations; sustain is a float value typically 
        between 0 and 1.
    ADSR( float attack, float decay, float sustain, float release )
        Construct an ADSR with attack, decay, sustain, and release values. Attack, 
        decay, and release values are in seconds; sustain is a float value 
        typically between 0 and 1.

    Delay( dur delay, dur max )
        Construct a Delay with delay length and delay max.
    Delay( dur delay )
        Construct a Delay with delay length and, implicitly, delay max.

    DelayA( dur delay, dur max )
        Construct a DelayA with delay length and delay max.
    DelayA( dur delay )
        Construct a DelayA with delay length and, implicitly, delay max.

    DelayL( dur delay, dur max )
        Construct a DelayL with delay length and delay max.
    DelayL( dur delay )
        Construct a DelayL with delay length and, implicitly, delay max.

    Echo( dur delay, dur max )
        Construct an Echo with delay length and delay max.
    Echo( dur delay )
        Construct an Echo with delay length and, implicitly, delay max.
==================
- (added) new member functions
==================
    dur Envelope.ramp( dur durationToTarget, float target );
        Over the given duration, ramp toward the specified target; returns the given 
        duration.
    dur Envelope.ramp( float secondsToTarget, float target );
        Over the given duration (in seconds), ramp toward the specified target; returns
        the given duration.

    void Delay.set( dur delay, dur max )
        Set delay length and delay max; delay should be <= max.

    void DelayA.set( dur delay, dur max )
        Set delay length and delay max; delay should be <= max.

    void DelayL.set( dur delay, dur max )
        Set delay length and delay max; delay should be <= max.

    void Echo.set( dur delay, dur max )
        Set delay length and delay max; delay should be <= max.
==================
- (added) examples/basic/envelope2.ck -- to show Envelope.ramp() in action
- (added) new MidiOut message voice message convenience functions (thanks @cviejo;
        previously these are possible only through `MidiOut.send( MidiMsg msg )`:
==================
    int send( int status, int data1, int data2 );
        Send out a MIDI message consisting of one status byte and two data bytes.
    int channelPressure(int channel, int pressure)
        Send out a channelPressure message.
    int controlChange(int channel, int controller, int value)
        Send out a controlChange message.
    int noteOff(int channel, int note, int velocity)
        Send out a noteOff message.
    int noteOn(int channel, int note, int velocity)
        Send out a noteOn message.
    int pitchBend(int channel, int value)
        Send out a pitchBend message.
    int pitchBend(int channel, int lsb, int msb)
        Send out a pitchBend message with fine and coarse values.
    int polyPressure(int channel, int note, int pressure)
        Send out a polyPressure message.
    int programChange(int channel, int program)
        Send out a programChange message.
==================
- (added) examples/midi/midiout2.ck -- demonstrates using the above channel
          voice messages
- (added) examples/deep/smb.ck -- a ChucK rendition of Super Mario Bros.
          original theme by Koji Kondo; (meticulously) modeled in ChucK by 
          Wesley Burchell in 2017
- (added) examples/basic/delay2.ck -- example showing DelayL constructor
          and modulating delay line length
- (added) examples/basic/blit3.ck -- lounge blit; made for svork concert
          lounge music for premiere in May 2024
- (added) examples/special/scream-o-matic/scream-o-matic.ck -- using 
          multiple LiSas for granular synthesis, to make continuous 
          scream generator
- (added) command line query system `--query:<name>`
- (added) CKDoc JSON output (terry feng)
- (added) Type type added to CKDoc script and deployed online:
    https://chuck.stanford.edu/doc/reference/utils.html#Type
- (added) CKDoc.sort( int ) -- toggle alphabetical sorting of functions and variables
    within Type documentation generation (thanks azaday)
- (fixed) globals events system synchronization (FYI this fixes a long-running,
    elusive Chunity crashing bug involving various syncers)
- (fixed) STK Moog parameters now consistent (should sound more Moog-y)
- (fixed) local non-control structure local scope Objects now correctly cleaned
          up at the end of local scope
- (updated) more and clearer error messages when initializing real-time audio
- (developer) streamline makefile targets 'test' 'doc' 'clean'


1.5.2.4 (April 2024)
=======
- (fixed) runtime exception line number reporting
- (fixed) 3rd-time array ugen link modulo connection between different # of channels
- (fixed) LiSaX crashing on duplicate constructor and destructors (thanks @eswartz)
- (fixed) LiSaX memory leak on creation due to duplicate constructor
- (reinstated) the UGen `bunghole` (a tribute to cultural icon Beavis); equivalent to
    blackhole in functionality


1.5.2.3 (April 2024)
=======
- (fixed) regression issue with connecting arrays of mono UGens to 
    non-mono ugens; e.g., `Gain a[2] => dac;`
    FYI examples/stereo/ugen-array.ck now works once again
- (updated) examples/array/array_ugens.ck contains additional 
    examples of array of ugens connecting with stereo ugens


1.5.2.2 (March 2024)
=======
- (added) Open Sound Control (OSC) address wildcard support
    (developer note) internally updated OSC implmentation to liblo v0.32
- (added) OSC wildcard examples
    examples/osc/wildcards/r-wildcards.ck
    examples/osc/wildcards/s-multi.ck
- (modified) semantics for connecting (=>) arrays of UGens;
    1) LHS[X] => RHS: each elements in LHS => to RHS
    // Gain A[3] => Gain B;
    2) LHS[X] => RHS[X]: one to one mapping
    // Gain C[3] => Gain D[3];
    3) LHS[X] => RHS[Y]: one to one mapping up to min(X,Y), after
       which elements in the smaller array will modulo to the beginning
       and connect to remaining elements in larger array
    // Gain E[2] => Gain F[3];
    4) LHS => RHS[X]: LHS => to each element in RHS
    // Gain G => Gain H[3];
- (added) connecting (=^) arrays of Unit Analyzers (UAnae)
- (added) examples/array/array_ugen.ck
- (added) Math.min( int, int ) and Math.max( int, int )
    NOTE: these overload the existing (float,float) min/max functions
- (fixed) error reporting for =^ =v --> --< operators
- (fixed) all oscillators Osc( freq, phase ) constructors; previously the phase
    was not set correctly
- (fixed) crash in cleaning up certain global objects (specifically those
    with default constructors), including OscIn, and ChuGL classes
    GGen, Geometry, FileTexture
- (fixed) incorrect CKDoc .help() labeling non-constructors as 
    constructors in user-defined classes
- (developer) added internal/audio-thread-callable setters for global 
    int / float arrays


1.5.2.1 (December 2023) ChuGL (alpha) => standard distribution
=======
- (added) ChuGL (alpha) is now part of the standard chuck distribution
    (macOS and windows; on linux, build from source)
    https://chuck.stanford.edu/chugl/
- (note) this alpha release of ChuGL (ChucK Graphics Library: a real-time
    audiovisual programming framework) only works with command-line `chuck`
    and does not work from within miniAudicle (miniAudicle support is on
    the ChuGL development roadmap)
=======
- (added) chugins can now implement a "info query function" to provide 
    chugin-specific infomation to be accessible from host, including:
    * chugin version (not to be confused with compatibility version)
    * chugin author(s)
    * chugin description
    * (optional) chugin URL
    * (optional) contact email
for example, in the chugin source:
```
// chugin info func
CK_DLL_INFO( MyChugin )
{
    // set info
    QUERY->setinfo( QUERY, CHUGIN_INFO_CHUGIN_VERSION, "v3.6.1" );
    QUERY->setinfo( QUERY, CHUGIN_INFO_AUTHORS, "Ana B. Croft" );
    QUERY->setinfo( QUERY, CHUGIN_INFO_DESCRIPTION, "what does it do?" );
    QUERY->setinfo( QUERY, CHUGIN_INFO_URL, "https://foo.com/FooBar" );
    QUERY->setinfo( QUERY, CHUGIN_INFO_EMAIL, "ana@foo.com" );
}
```
- (updated) revert chugin/host compatibility policy
    chugin major version must == host major version
    chugin minor version must <= host minor version
  (previously in 1.5.2.0) chugin AND host API version must match


1.5.2.0 (November 2023) "Better Late Than Never...constructors"
=======
- (added) class constructors
- (added) overloadable class constructors definitions
============
constructors can be invoked when declaring a variable or with `new`:
```
// connecting UGens, with construtors
SinOsc foo(440) => Gain g(.5) => dac;
// `new` and assignment
new TriOsc(440,pi/2) @=> Osc @ oscillator;
// can combine constructors with arrays
string arr("foo")[10];
```
============
constructors can be defined and overloaded in class definitions:
```
class Foo
{
    // a member variable
    1 => int num;

    // constructor "default"
    fun @construct() { 2 => num; }

    // another constructor
    fun @construct( int x ) { x => num; }

    // yet another constructor
    fun @construct( int x, int y ) { x*y => num; }

    // alternate way of define a constructor, using the class name
    fun Foo( int x, int y, int z ) { x*y*z => num; }

    // destructor
    fun @destruct() { <<< "bye:", this.num >>>; }
}

// constructor "default"
Foo f1();
// another constructor
Foo f2(15);
// yet another constructor
new Foo(8,9) @=> Foo @ f3;
// yet another constructor
new Foo(10,11,12) @=> Foo @ f4;
// print
<<< f1.num, f2.num, f3.num, f4.num >>>;
```
- (added) examples/class/constructors.ck
- (added) examples/class/destructor.ck
- (added) CKDoc and .help() support for constructors
- (added) overloaded functions can now have different return types;
for example:
```
    // foo() overload 1 returns float
    fun float foo( float b ) { return b; }
    // foo() overload 2 returns int
    fun int foo( int a ) { return a; }
```
- (fixed) Type.of("int[][]").isArray() now correctly returns true
- (fixed) overzealous dependency validation for member variable usage
    from other classes
- (fixed) overzealous dependency validation for file-level variable
    usage from functions
- (fixed) disambiguating overloaded functions to choose the "closest" match
    by function call argument type inheritance "distance" to function
    argument type
- (added) Shred.parent() and Shred.ancestor()
- (added) compiler error for ambiguous function calls when there is no
    "closest" match
- (fixed) array popFront() crash on Object-based arrays
- (updated) ChucK API doucmentation for constructors
- (added) overloaded constructors added (more to come)
==================
    Gain( float gain );
        Construct a Gain with default value.
    SndBuf( string path );
        Construct a SndBuf with the 'path' to a sound file to read.
    SndBuf( string path, float rate );
        Construct a SndBuf with the 'path' to a sound file to read, and a default playback 'rate' (1.0 is normal rate)
    SndBuf( string path, float rate, int pos );
        Construct a SndBuf with the 'path' to a sound file to read, a default playback 'rate' (1.0 is normal rate), and starting at sample position 'pos'
    Step( float value );
        Construct a Step with a default value.
    string( string str );
        Construct a string as a copy of another string.
    Osc( float freq );
        Construct a Osc at specified frequency.
    Osc( float freq, float phase );
        Construct an Osc at specified frequency and phase.
    (similarly for SinOsc, TriOsc, SqrOsc, SawOsc, PulseOsc, Phasor)
==================
chugins API update
==================
- (updated) chugin API version updated to 10.1
  -- complete decoupling of chugins interface and chuck core 
     implementation details
  -- new chugins runtime API functions to provide access
     to chuck core operations that is safe across the shared/dynamic
     library boudaries between chugins and a chuck host
     (see Chuck_DL_Api in chuck_dl.h for details)
- (updated) all chugins can now include a single header `chugin.h`
     with no additional header dependencies
     [see: https://github.com/ccrma/cheaders/tree/main/include]
     FYI: this single-header `chugin.h` is generated from a minimal
     set of chuck core header files: chuck_def.h chuck_symbol.h
     chuck_absyn.h and chuck_dl.h
- (updated) it is highly recommended that all chugins update to
     using chugin.h; it is still possible to include chuck headers
     directly (either chuck_dl.h or chuck.h), but must #define
     __CHUCK_CHUGIN__ macro (if using chugin.h, this macro is always
     defined at the top of file)
- (updated) chugin AND host API version must now match
     (previously only the major version must match)
- (added) chugins runtime API support for creating arrays from chugins
- (added) chugins support for overloading constructors


1.5.1.8 (October 2023) "Halloween Release"
=======
(note) memory management is ghoulishly frightful!

- (fixed) an issue with memory management / reference counting across 
    overloaded operations that return Object
- (fixed) an issue with reference count cleanup on recursive functions
    that return Objects
- (fixed) an issue with reference count cleanup on 'new' operator,
    e.g., (new Foo).f();
- (updated) reduced memory management dependency between language-defined 
    objects and their "parent" shreds
- (updated) --color:ON and --color now will always output ANSI color 
    codes, regardless of TTY status; (FYI --color:AUTO is unchanged
    and is the same as default, i.e., enable color terminal if TTY 
    detected; disable otherwise
- (added, developer) chugins API float array access


1.5.1.7 (October 2023) "vec2"
=======
- (added) new type 'vec2' 2D vector type
    for 2D animation (ChuGL) as well as texture mapping UV or ST 
    coordinates; access fields with .x/.y OR .u/.v OR .s/.t
- (added) new examples/vector/vec2.ck
- (reworked) memory management across function calls that return
    Object types; now correctly tracks all instances within a 
    statement and balances reference counts; previously there was
    a chance that object refcount were not correctly released,
    causing incorrect behavior including memory leaks.
    "dangling object references tracking and cleanup"
    examples include (assumption: foo() returns an Object):
    `foo().bar;` or `foo(), foo()` (multi-expression stmt) or
    `while( foo().bar ) { ... }` (loop stmt) and many more.
- (fixed) incorrect reference count for certain usages of 'null'
    where the expression was interpreted incorrectly as a
    function call, e.g., obj == null


1.5.1.6 (October 2023) patch release
=======
- (fixed) a serious issue accessing vec3/vec4 fields (.x, .y, .z. .w)
  where the operand stack was incorrectly cleaned, which could lead
  to stack overflow. This issue has been addressed.


=======
NOTE: 1.5.1.5 is the alpha-release / soft launch of ChuGL, a unified 
audiovisual programming framework built into the ChucK programming
language. It offers real-time, unified audio synthesis and 3D/2D graphics 
programming in a single strongly-timed language.
------
https://chuck.stanford.edu/chugl/
=======


1.5.1.5 (October 2023) "operator overloading + chugins API 9.0"
=======
- (added) operator overloading is here!
    Most operator can now be overloaded, within their respective existing
    forms in the language (e.g., binary operators such as '+' and '=>'
    can be overloaded as binary operators, but not as unary operators).
    Similar to class definitions, operator overloads are local in scope 
    to the file context, unless declared with 'public'. operator 
    overloading marked as 'public' will persists until 1) the VM stops or 
    2) the VM is cleared/reset.
    //-----------------------------------------------------------
    // the general format for overload an operator is as follows:
    //-----------------------------------------------------------
    // let's say we define a custom class...
    public class Foo { int num; }

    // PUBLIC operator overloading (transcends contexts and files;
    // will persist until stop VM or clear VM. NOTE the use of 'public' 
    // instead of 'fun' (fun for all!)
    public Foo @operator =^( Foo lhs, Foo rhs )
    { /* do stuff for Foo =^ Foo */ return rhs; }

    // LOCAL binary operator overload for '=>' (local to this context)
    fun Foo @operator =>( Foo lhs, Foo rhs )
    { /* do stuff for Foo => Foo */ return rhs; }

    // define binary operator overload for '+'
    fun Foo @operator +( Foo lhs, Foo rhs )
    { Foo retval; lhs.num + rhs.num => retval.num; return retval; }

    // define binary operator overload for '*'
    fun Foo @operator *( Foo lhs, Foo rhs )
    { Foo retval; lhs.num * rhs.num => retval.num; return retval; }

    // define unary operator overload for '!'
    fun int @operator !( Foo foo )
    { return !foo.num; }

    // define postfix operator overload for '++'
    fun Foo @operator ( Foo foo ) ++
    { foo.num++; return foo; }

    //-----------------------------------------------------------
    // using the new overloaded operators
    //-----------------------------------------------------------
    // create 2 Foos
    Foo a, b; 1 => a.num; 2 => b.num;
    // operator in action (follows default ck operator precedence)
    a + b * b + a @=> Foo c;
    // post ++ on c
    c++;
    // should print 7
    <<< c.num >>>;
    //-----------------------------------------------------------
- (added) new examples showing basic operator overloading usage
    examples/oper/overload_overview.ck
    examples/oper/overload_pre_post.ck
    examples/oper/overload_public.ck
    examples/oper/overload_gru.ck
- (added) the "gruck operator" --> (graphical chuck operator) as part
    of ChuGL (ChucK Graphics Library), which will be part of the ChucK
    language
- (added) Machine function to on-the-fly control operator overloading stack
    static void resetOperators();
        Reset operator overloading state to default startup state; 
        removes all public @operator overloads; use with care.
- (added) new Machine function for getting number of shreds currently in VM
	static int numShreds();
	    Get the number of shreds currently in the VM.
- (added) improved exception reporting and stack-overflow detection and 
    handling. Overall, these change improve system robustness and runtime
    information.
- (added) two new (and somewhat arcane) Shred methods to support "extreme 
    shredding" use cases:
        ----
	int childMemSize( int sizeInBytes );
	    Set size hint of per-shred call stack ("mem") for children 
	    shreds subsequently sporked from the calling shred (NOTE this 
	    size hint does not affect the calling shred--only its 
	    descendants); if sizeInBytes <= 0, the size hint is set to 
	    the VM default. (FYI This is an arcane functionality that 
	    most programmers never need to worry about. Advanced usage: 
	    set size hint to small values (e.g., 1K) to support A LOT 
	    (e.g., >10000) of simultaneous shreds; set size hint to large 
	    values (e.g., >65K) to spork functions with extremely deep 
	    recursion, or to support A LOT (>10000) of declared local 
	    variables. Use with care.)
	int childMemSize();
	    Get the memory stack size hint (in bytes) for shreds sporked 
	    from this one.
	int childRegSize( int sizeInBytes );
	    Set size hint of per-shred operand stack ("reg") for children 
	    shreds subsequently sporked from the calling shred (NOTE this 
	    size hint does not affect the calling shred--only its 
	    descendants); if sizeInBytes <= 0, the size hint is set to 
	    the VM default. (FYI This is an arcane functionality 
	    that most programmers never need to worry about. Advanced 
	    usage: set size hint to small values (e.g., 256 bytes) to 
	    support A LOT (>10000) of simultaneous shreds; set size hint 
	    to large values (e.g., >20K) to spork functions with 
	    extremely lengthy (>10000) statements, including array 
	    initializer lists. Use with care.)
	int childRegSize();
	    Get the operand stack size hint (in bytes) for shreds sporked 
	    from this one.
        ----
- (added) FileIO.open() now takes "special:auto" as the filename (output
    only) to write to a new file with auto-generated filename in the 
    current directory (based on the current system time, precise to 
    second;NOTE files created into way at the same system time will have 
    the same auto-generated filename and may conflict or fail to open).
    The "auto" prefix and extension can be set and retrieved using the
    following new functions to FileIO:
	---
	string autoExtension();
	    Get auto extension for "special:auto" filename generation 
	    (applicable to file writing only).
	string autoPrefix();
	    Get auto prefix for "special:auto" filename generation 
	    (applicable to file writing only).
	void autoPrefixExtension( string prefix, string extension );
	    Set auto prefix and extension for "special:auto" filename 
	    generation (applicable to file writing only).
	---
- (fixed) float *=> vec4 now works as intended (instead of producing a
    a compilation error)
- (fixed) on Windows and --verbose level SYSTEM or higher, when a chugin
    fails to load, instead of displaying a cryptic error code (e.g., 
    "reason: 1920"), the error code is translating into an error message 
    and displayed (e.g., "reason: The file cannot be accessed by the system.")
    (azaday)
- (fixed) on certain systems, program ending with a single-line // comment
    could crash; affects miniAudicle, WebChucK, Machine.eval() containing
    code that ending with a trailing comment
- (fixed) on-the-fly programming (OTF) system was incorrectly cleaning
    up file descriptors and leading to instability
- (updated) ConsoleInput.prompt( text ) now no longer prints an extra 
    space (" ") after prompt text
- (updated) chugins headers version incremented to 9.0
- (added; chugins development) overhauled dynamic linking API to access
    chuck host-side operations; this greatly expands chugins capabilities
    but will unfortunately require API changes that will break chugin
    builds that uses the existing API.
    (check out chuck_dl.h: `namespace Chuck_DL_Api`)
- (added; chugins development) ability to overload operators from chugin
    query functions in C++:
    // add binary operator overload; args included
    f_add_op_overload_binary add_op_overload_binary;
    // add unary (prefix) operator overload; arg included
    f_add_op_overload_prefix add_op_overload_prefix;
    // add unary (postfix) operator overload; arg included
    f_add_op_overload_postfix add_op_overload_postfix;
- (added; chugins development) capability to invoke chuck language-side
    member functions (in chuck) from chugins (in C++)
    // invoke Object member function (defined either in chuck or c++)
    // NOTE this will call the member function in IMMEDIATE MODE,
    // marking it as a time-critical function when called in this 
    // manner; any time/event operations therein will throw an exception
    Chuck_DL_Return API->vm->invoke_mfun_immediate_mode( 
        Chuck_Object * obj, t_CKUINT func_vt_offset, Chuck_VM * vm, 
        Chuck_VM_Shred * shred, Chuck_DL_Arg * ARGS, t_CKUINT numArgs );
- (added; chugins development) new API->type API for C++/chugins to 
    lookup types in the type system, virtual function offsets (useful
    for API->vm->invoke_mfun_immediate_mode() above)
- (added and updated; chugins development) across all existing
    chugins DL API and many additions; the chugins runtime API 9.0
    =============================
    // C++ chugins runtime API for VM access (access from chugins using API->vm->...)
    // get sample rate | 1.5.1.4
    t_CKUINT srate( Chuck_VM * vm );
    // get chuck now | 1.5.1.4
    t_CKTIME now( Chuck_VM * vm );
    // create a new lock-free one-producer, one-consumer buffer | 1.5.1.4
    CBufferSimple * create_event_buffer( Chuck_VM * vm );
    // queue an event; num_msg must be 1; buffer should be created using create_event_buffer() above | 1.5.1.4
    t_CKBOOL queue_event( Chuck_VM * vm, Chuck_Event * event, t_CKINT num_msg, CBufferSimple * buffer );
    // invoke Chuck_Object member function (defined either in chuck or c++) | 1.5.1.4 (ge & andrew)
    // NOTE this will call the member function in IMMEDIATE MODE,
    // marking it as a time-critical function when called in this manner;
    // any time/event operations therein will throw an exception
    Chuck_DL_Return invoke_mfun_immediate_mode( Chuck_Object * obj, t_CKUINT func_vt_offset,
        Chuck_VM * vm, Chuck_VM_Shred * shred, Chuck_DL_Arg * ARGS, t_CKUINT numArgs );
    // throw an exception; if shred is passed in, it will be halted
    void throw_exception( const char * exception, const char * desc, Chuck_VM_Shred * shred );
    // log a message in the chuck logging system
    void em_log( t_CKINT level, const char * text );
    // system function: remove all shreds in VM; use with care
    void remove_all_shreds( Chuck_VM * vm );
    --------------------------------
    // C++ chugins runtime API for object access (access using API->object->...)
    // function pointer get_type()
    Type get_type( Object object );
    // add reference count
    void add_ref( Object object );
    // release reference count
    void release( Object object );
    // get reference count
    t_CKUINT refcount( Object object );
    // instantiating and initializing a ChucK object by type, with reference to a parent shred
    // if addRef == TRUE the newly created object will have a reference count of 1; otherwise 0
    // NOTE set addRef to TRUE if you intend to keep a reference of the newly created object around
    // NOTE set addRef to FALSE if the created object is to be returned without keeping a reference around
    Object create( Chuck_VM_Shred *, Type type, t_CKBOOL addRef );
    // instantiating and initializing a ChucK object by type, with no reference to a parent shred
    // if addRef == TRUE the newly created object will have a reference count of 1; otherwise 0
    Object create_without_shred( Chuck_VM *, Type type, t_CKBOOL addRef );
    // instantiate and initialize a ChucK string by type
    // if addRef == TRUE the newly created object will have a reference count of 1; otherwise 0
    String create_string( Chuck_VM *, const char * value, t_CKBOOL addRef );
    // function pointers for get_mvar_*()
    t_CKBOOL get_mvar_int( Object object, const char * name, t_CKINT & value );
    t_CKBOOL get_mvar_float( Object object, const char * name, t_CKFLOAT & value );
    t_CKBOOL get_mvar_dur( Object object, const char * name, t_CKDUR & value );
    t_CKBOOL get_mvar_time( Object object, const char * name, t_CKTIME & value );
    t_CKBOOL get_mvar_string( Object object, const char * name, String & value );
    t_CKBOOL get_mvar_object( Object object, const char * name, Object & value );
    // function pointer for set_string()
    t_CKBOOL set_string( String string, const char * value );
    // array_int operations
    t_CKBOOL array_int_size( ArrayInt array, t_CKINT & value );
    t_CKBOOL array_int_push_back( ArrayInt array, t_CKUINT value );
    t_CKBOOL array_int_get_idx( ArrayInt array, t_CKINT idx, t_CKUINT & value );
    t_CKBOOL array_int_get_key( ArrayInt array, const std::string & key, t_CKUINT & value );
    --------------------------------
    // C++ chugins runtime API for type access (new; access using API->type->...)
    // lookup type by name
    Type lookup( Chuck_VM *, const char * name );
    // get vtable offset for named function; if overloaded, returns first;
    // (returns < 0 if not found)
    t_CKINT get_vtable_offset( Chuck_VM *, Type type, const char * value );
    // test if two chuck types are equal
    t_CKBOOL is_equal(Type lhs, Type rhs);
    // test if lhs is a type of rhs (e.g., SinOsc is a type of UGen)
    t_CKBOOL isa(Type lhs, Type rhs);
    =============================


1.5.1.3 (September 2023) "ChucK to School"
=======
(note) this release of chuck addresses a number of issues from long-time 
    language bugs to documentation updates to expanding Machine functions 
    for VM/shred management to improved Open Sound Control support. Over 
    the dozen releases since chuck-1.5.0.0, this release is strongly-timed
    for students and instructors coming back to school in Fall 2023!
    (One of our ongoing priorities is to make the language + tools 
    better for teaching, research, and of course music making.)

- (updated) Machine.add()/replace()/remove()/status() now re-implemented
    internally for both performance and greater compatibility (now can
    be used with no dependencies on OTF system, make it possible to call
    these from systems like WebChucK).
- (added) new and updated Machine functions
	---------
	** new ** static int removeLastShred();
	    Remove the most recently added shred in the VM (could be the
	    shred calling this function); returns the ID of the removed 
	    shred.
	** new ** static int resetShredID();
	    Reset shred IDs to 1 + the highest current shred ID in the VM; 
	    can be used as shred management to keep shred IDs low, after 
	    a lot of sporks. Returns what the next shred ID would be.
	** new ** static void removeAllShreds();
	    Remove all shreds in the VM (including the shred calling this 
	    function).
	** new ** static void clearVM();
	    Reset the type system, removing all user-defined types and all 
	    global variables; removes all shreds in the VM (including the 
	    shred calling this function). Use with care.
	** new ** static void printStatus();
	    Print (to terminal or console) the current status of the VM.
	** new ** static void printTimeCheck();
	    Print (to terminal or console) the current time information in
	    the VM.
	-------------
	** updated ** static int add( string path );
	    Compile and spork a new shred from file at 'path' into the VM; 
	    returns the new shred ID. It is possible to include arguments 
	    with the file being added, e.g., `Machine.add( 
	   "foo.ck:bar:3:5.0" )`.
	** updated ** static int replace( int id, string path );
	    Replace shred with new shred from file. Returns new shred ID, 
	    or 0 on error. It is possible to include arguments, e.g., 
	    `Machine.replace( outID, "foo.ck:bar:3:5.0" )`.
	** updated ** static int remove( int id );
	    Remove shred from VM by shred ID (returned by Machine.add).
	** updated ** static int status();
	    Print the current status of the VM;
	    legacy version of printStatus().
	-------------
- (updated) Machine.add( filepath ) no longer introduces a potential
    real-time audio interruption on macOS ** for all filepath that does 
    not contain ~ **; currently, path resolution for ~ or ~[username] in 
    macOS consistently causes audio clicks, likely due to implementation
    of underlying system function (e.g., wordexp()) to resolve ~ 
    (hypothesis: wordexp() function performs IO-blocking)
- (added) function to expand platform specific file path
	static string expandPath( string path );
	    Expand platform-specific filepath to an absolute path, which 
	    is returned. On macOS and Linux expandPath() will attempt to 
	    resolve `~` or `~[username]`; on Windows expandPath() will 
	    attempt to resolve %USERNAME%. (Known issue: (macOS) 
	    expandPath currently introduced an audio click; it 
	    recommended to call expandPath() at the beginning; e.g., 
	    expanding path ahead of time could avoid a click instead of 
	    calling Machine.add() on a filepath with `~`.)
- (added) a new (3rd) string.replace() function
	void replace( string from, string to );
	    Replace all instances of 'from' in the string with 'to'.
  (for reference the existing string.replace() function)
	void replace( int position, string str );
	    Replace characters from 'position' with contents of 'str'.
	void replace( int position, int length, string str );
	    Replace 'length' characters from 'position' with contents of 'str'.
- (added) examples/string/replace.ck
- (updated) move real-time audio system warnings to log level "WARN"; this 
    should result in less clutter printed, in particular on Linux/ALSA.
- (updated) CKDoc now prints class functions before variables
- (added, chugin development) new backend chugin <=> chuck host API 
    functions for array.size(), array.get_idx(), array.get_key()
    (@nshaheed) 
- (fixed) various documentation misspellings (thanks @barak)
- (fixed) variable look-up priorities when multiple variables of the same 
    name are declared in various situations in the same file (shadowing); 
    this resolves issues within a subclass incorrectly accessing 
    variables of the same name (declared as local variable vs. member in 
    a parent class vs. global-scope variables), depending on where it's
    accessed from.
    ---
    updated convention for value lookup priority (in case of shadowing)
    1) first look in the same scope
    2) if not found, and if inside a class def, look up-scope within 
       class (but no further)
    3) if not found, and if inside a class def, look in parent (for 
       inherited value)
    4) if still not found, look all the way up to global scope
    ---
    for example: chuck/src/test/01-Basic/194-value-lookup-order.ck
    ---
- (fixed) using => to connect from/to empty UGen array declaration no 
    longer results in a crash; instead there is now a compiler error:
```
a.ck:8:17: error: cannot connect '=>' to empty array '[ ]' declaration...
[8] [foo] => SinOsc bars[];
                    ^
a.ck: ...(hint: declare 'bars' as an non-empty array)
a.ck: ...(or if assignment was the intent, use '@=>' instead)
```
- (fixed) duplicate function declaration no longer causes a crash after
    reporting the error
```
// example of duplicate function declarations
fun void bar() { }
fun void bar() { }
```
- (fixed) assigning to constants such as `pi`, `second`, or `Math.PI` now
    results in a compiler error; previously the outcome was undefined and
    in certain case could cause a crash.
- (fixed) concatenating a function reference with a string now produces a
    compiler error; previously this would lead to a runtime crash.
```
a.ck:17:9: error: cannot perform '+' on string and '[function]'
[17] <<< " " + f.getFoo >>>;
             ^
a.ck:17:13: error: ...(hint: to call the function, add '()' and any arguments)
[17] <<< " " + f.getFoo >>>;
                 ^
```
- (fixed) an issue appending arrays to arrays for non-integer types
```
float foo[0][0]; float bar[0];
foo << bar;
```
- (fixed) an issue with OscOut on Windows, which can crash on object cleanup
    due to incorrect windows-specific socket closing
- (fixed; reworked) OSC dispatch for multiple OscIn clients listening on 
    the same OSC address; the crash has bee resolved, and the OSC 
    incoming server message dispatch has been reworked
- (re-added) 'Chubgraph' has been "re-deprecated", which actually means 
    older code that use 'Chubgraph' instead of 'Chugraph" will now work
    again, with the deprecation warning (previously `Chubgraph` would 
    result in a compiler error):
    `deprecated: 'Chubgraph' --> use: 'Chugraph' instead`
- (updated) minor improvements in compiler error reporting; more 
    accurate position accuracy for binary operators, including =>,
    @=>, and =^
- (updated) log level 3 (SEVERE) has been renamed to (HERALD)
- (updated) improved stability on ctrl-c shutdown for real-time audio
    and HID management
- (added) examples/effects/autotune.ck
---
- (added) WebChucK support for Machine.add()/replace()/remove()/removeAll()
- (added) WebChucK IDE now supports the ability to upload .ck files for 
    Machine (@terryzfeng) https://chuck.stanford.edu/ide/
- (updated) for Chugin developers, the `chuginate` tool has been 
    modernized (spencer and ge) -- 0) chuginate updated from using
    python2 to python3; 1) in addition to a boilerplate C++ project for 
    a chugin, chuginate now also generates a boilerplate NAME-test.ck 
    ChucK program; 2) more informative comments in the boilerplate C++ 
    code; 3) updated makefiles for all platforms.


1.5.1.2 (August 2023)
=======
- (updated) the long-time and often cryptic "cannot bind to port: 8888"
    message has been reworked: 1) an explanation has been added to the
    possible cause (e.g., another chuck VM is running and currently
    has the port open) and implication (this chuck VM will not receive
    OTF commands over the network); 2) the printing of this message has
    been moved by default to log level 2 (SYSTEM) with further information
    on log level 5 (INFO) UNLESS the '--loop` flag is present, which
    signals intention to use the VM as an OTF command listener (and the
    warning is more likely to be relevant information). This should
    hopefully reduce confusion, as well as improve automations that
    examine the output of chuck. (thanks to @barak for elucidating the
    issue!)
- (added) --cmd-listener:{on|off} enables or disables listening for 
    network OTF (on-the-fly programming) command messages (e.g., add, 
    replace, remove, etc.). The default is ON; setting to OFF will prevent 
    chuck VM from attempting to open network server listener. (NOTE: this 
    option does NOT affect in-language networking, e.g., with Open Sound
    Control.)


1.5.1.1 (August 2023)
=======
(note) this patch release fixes a number of issues related to recently added
    language features; it also adds some "syntactic sugar" in the form of
    allowing trailing commas in array initializer lists, as well as a set 
    of range() functions for generating arrays of ranges of value.

- (added) trailing commas in array initializer lists are now permitted
```
// an array initializer list (aka array literal), as usual
[1,2,3] @=> int foo[];

// now also permitted: trailing comma after last element
[1,2,3,] @=> int bar[];
```
- (added) Std functions for generating arrays containing a range of 
    values (nshaheed)
	static int[] Std.range( int stop );
	    Return array containing the range [0,stop).
	static int[] Std.range( int start, int stop );
	    Return array containing the range [start,stop).
	static int[] Std.range( int start, int stop, int step );
	    Return array containing values from start up to (but not including) stop,
	    hopping by step.
- (re-added) backtick(`)-delimited strings; context: needed for FaucK
    (FAUST in ChucK) through the Faust chugin
- (fixed) issue related to multiple empty statements (e.g., ;;;;) being
    incorrectly handled by the function control path analysis
- (fixed) issue related to incorrect out-of-order dependencies across
    different files / contexts (thanks Michael Heuer for investigating)
- (fixed) class member/static variables can now be accessed, as before,
    from anywhere in the same file, regardless of order of declaration
    (thanks Michael Heuer for investigating)
```
Foo foo;
// using val above declaration is part of language semantics
// (but due to regression bug was broken in 1.5.0.8)
// this should work once again
5 => foo.val;

class Foo
{
    int val;
}
```
- (updated) 'auto' type is now disallowed as a top-level class variables,
    instance or static; since these variables could be used from outside the class,
    1) this potentially leads to more intentional code and 2) currently there is no
    mechanism to resolve the 'auto' until type checking stage such that out-of-order
    access of class variables are resolved.
```
// class definition
class Foo
{
    // ok
    for( auto x : [1,2,3] ) { <<< x >>>; }
    // ok
    fun void bar() { 4 => auto y; }
    // ok
    if( true ) { 5 => auto x; }
    // ok
    { 6 => auto x; }
    // not ok *** compiler should report error
    7 => auto m_var;
    // not ok *** compiler should report error
    8 => static auto m_var;
}
```
- (fixed) a memory leak associated with array declarations
- (fixed) chout and cherr now properly accounts for IO redirect out of
    chuck; this addresses issue with miniAudicle console output, and
    also affects other C++ hosts embedding chuck core.


1.5.1.0 (August 2023)
=======
(note) this release (1.5.1.0) updates a long-standing policy regarding 
`return`statements in function declarations; adds @array.sort(), a new 
command-line option, general bug fixes and stability improvements.

(note) much has been added between 1.5.0.0 and 1.5.1.0, including:
  * new for-each loop syntax for iterating through arrays (1.5.0.8)
  * enhanced and more accurate compiler error reporting; now
    highlights code and pinpointing error location in code (1.5.0.5)
  * color terminal support for CLI chuck (1.5.0.5)
  * expanded class library support in IO, random number generation,
    Machine.eval(), chugins management, and array
  * new features in CLI chuck, miniAudicle, WebChucK & IDE
  * (developer) The Great ChucK Repo Cleanup of 2023 (1.5.0.2)
  * (developer) streamlined c++ integration for those wishing to
    incorporate ChucK core into other c++ hosts (1.5.0.7)
    https://github.com/ccrma/chuck/tree/main/src/host-examples
  * (see below for more information)
===
- (update) `return` statements in function definitions:

PREVIOUSLY: chuck does not require all control paths in non-void 
functions to explicitly return values -- in cases of missing `return` 
statements at the end of a function, ChucK implicitly sets the return 
value to some form of 0 or null, depending on the return type.

NEW: the chuck compiler now rejects non-void function definitions in 
which not all control paths return a value, and will print a compiler
error in the form of:

  "error: not all control paths in 'fun int f()' return a value"

RATIONALE: while *** this may break some existing code (apologies!) ***
that assumed the previous return semantics (or forgot to return a value
or accidentally declared a function as returning something when it should
return `void`), we believe this change will be more beneficial in the
long-term and will lead to clearer, more intentional code.

example:
```
// as of chuck-1.5.1.0, will result in a compiler error
fun int foo()
{
    // no return
}
```

ChucK performs syntactical analysis of function control paths:
```
// this is valid code, even though the function does not end in a `return`
fun float foo( int v )
{
    if( v == 1 ) return 1;
    else if( v == 2 ) return 2;
    else return 3;
}

// this code will result in a compiler error, since there is no `else`
// and no subsequent `return`
fun float foo( int v )
{
    if( v == 1 ) return 1;
    else if( v == 2 ) return 2;
}
```
- (added) array sorting
	void sort()
        Sort the contents of the array in ascending order.
  ** array sorting semantics, by type **
        int[]: sort by value
      float[]: sort by value
    complex[]: sort by magnitude (2-norm) with phase as tie-breaker
      polar[]: sort by magnitude with phase as tie-breaker
       vec3[]: sort by magnitude with x then y then z
       vec4[]: sort by magnitude with x then y then z then w
- (added) new examples
    |- examples/array/array_sort.ck
- (added) IO (cherr, chout, FileIO) for complex, polar, vec3, vec3
    e.g., cherr <= #(1,1) <= IO.nl();
    e.g., chout <= #(1,1)$polar <= IO.nl();
- (added) overloaded Std.getenv() variant (thanks @ynohtna)
        string getenv(string value)
        Get the value of an environment variable, returning the provided 
            default if unset.
- (added) --pid-file:<FILENAME> CLI option (thanks @ynohtna)
    "If this flag is specified with argument, chuck will attempt to write 
     its process ID to the given file upon startup, and then remove that 
     file upon shutdown. This assists external process supervision 
     (through tools like monit,etc) for long-running installations that 
     need auto-rebooting, instant kill switches for live performances, 
     and other programmatic external process control."
- (fixed) for-each for complex, polar, vec3, vec4 types;
    (e.g., `for( vec3 n : myVec3Array ) { ... }`
- (fixed) compiler issue (introduced in 1.5.0.8) where a declaration in 
    the middle of a three-part chuck statement incorrectly reports error
    that variable already declared (e.g., `440 => float f => osc.freq;`)
- (fixed) error reporting printing for a few binary and unary operators:
    spork ~, typeof, sizeof, new, <-, ->
- (fixed) implicit cast from 'int' to 'float' in function returns;
    (e.g., `fun float foo() { return 5; }`)


1.5.0.8 (August 2023)
=======
(note) this release introduces a for-each control structure for more 
easily iterating over arrays, as well as an experimental 'auto' type. 
array support has also been expanded; internally, engine support has been 
added for a number of features in WebChucK and WebChucK IDE, including 
retrieving and display the chuck 'now', along with a number of critical 
chuck parameters; updated ChucK c++ integration

- (added) new 'for' control structure in this general syntax:
      for( VAR : ARRAY )
      { ... }
    where VAR is a declared variable of the same base type as the ARRAY,
    in each iteration of the for loop body, VAR will take on the value of
    each element in ARRAY, until the end of ARRAY is reached. For example:
      ```
      // create empty array
      float array[0];
      // append
      array << 1 << 2.5 << 3;
      // for each element 'x' in array
      for( float x : array )
      {
          // print the element
          <<< x >>>;
      }
      ```
    or loop over an array literal of values:
      ```
      // iterating over an array literal
      for( int x : [ 1, 2, 3 ] ) { <<< x >>>; }
      ```
- (added) new examples using for-each control structure
    examples/array/foreach-1.ck
    examples/array/foreach-2.ck
    examples/array/foreach-3.ck
    examples/array/foreach-4.ck
    examples/array/foreach-5.ck
    examples/array/foreach-6.ck
    examples/ctrl/ctrl_foreach.ck
- (added) new 'auto' type; in certain declarations, infers the actual
  type of a variable from context. For example:
     ```
     // 'a' will be automatically typed as 'float'
     1.5 => auto a;
     // 'arr' will be automatically typed as 'int[]'
     [1,2,3] @=> auto arr[];
     // can use in the new for-each control structure
     for( auto x : arr )
     // x is automatically typed as 'int'
     { <<< x >>>; }
     ```
- (added) new examples for 'auto'
    examples/type/type_auto.ck
    examples/array/foreach-auto1.ck
    examples/array/foreach-auto2.ck
- (added) new array operations
	void erase(int position)
	    Remove element at 'position' from the array.
	void erase(int begin, int end)
	    Remove element(s) in the range [begin,end).
	void popFront()
	    Remove the first element of the array.
  See full array API reference with examples:
    https://chuck.stanford.edu/doc/reference/base.html#@array
- (added) new array examples
    examples/array/array_append.ck
    examples/array/array_erase.ck
    examples/array/array_erase2.ck
- (update) map-only function @array.find(string) has been renamed to
    @array.isInMap(string) to avoid confusion with vector
- (added) error checking for out-of-order dependency issues where
  a function is called (or a class instantiated) that would skip
  a needed variable initialization; this addresses a long-standing
  issue that has caused much confusion because previously the issue
  failed but silently.
  ---
  For example, consider this 'foobar.ck' code
  ```
    // does not work here: precedes 'bar' initialization
    foo();
    // where 'bar' initializes
    5 => int bar;
    // FYI calling foo() works here: after 'bar' initializes
    // foo();

    // the function definition
    fun void foo()
    {
        // needs 'bar' to be initialized
        <<< "bar:", bar >>>;
    }
  ```
  The new resulting compiler error:
  ```
    > chuck foobar.ck
    foobar.ck:4:1: error: calling 'foo()' at this point skips
                   initialization of a needed variable:
    [4] foo();
        ^
    foobar.ck:7:10: error: ...(note: this skipped variable
                    initialization is needed by 'fun void foo()')
    [7] 5 => int bar;
                 ^
    foobar.ck:16:17: error: ...(note: this is where the variable
                     is used within 'fun void foo()')
    [16]     <<< "bar:", bar >>>;
                         ^
    error-depend-var.ck: ...(hint: try calling 'foo()' after the
                         variable initialization)
  ```
  ---
  Similar errors are reported for class definitions that reference
    file-top-level variables, etc.
- (added) error reporting for public class definitions that access
    out-of-class local variables and functions; this is necessary
    to disallow since public classes can be instantiated from any
    context (file or code)
- (updated, documentation) STK classes HnkyTonk and FrencHrn now 
  properly included in the API reference, and with more examples:
    https://chuck.stanford.edu/doc/reference/ugens-stk.html#HnkyTonk
    https://chuck.stanford.edu/doc/reference/ugens-stk.html#FrencHrn
- (added) new STK examples
    https://chuck.stanford.edu/doc/examples/stk/honkeytonk-algo1.ck
    https://chuck.stanford.edu/doc/examples/stk/honkeytonk-algo3.ck
    https://chuck.stanford.edu/doc/examples/stk/frenchrn-algo2.ck
- (added) new examples for Event and SndBuf and repeat
    examples/event/event-extend2.ck
    examples/basic/doh.ck
    examples/ctrl/ctrl_repeat.ck
- (added) error checking for public class definitions using an external 
    file-level, non-global variable
- (updated, developer) core VM code streamlined for cleaner operation
  regarding shreds status, remove.all, and access to these from C++;
  can now use a callback function to get replies from VM queue_msg()
- (updated, developer) re-worked ChucK::compileFile() and
    ChucK::compileCode() to immediately make sporked shred ID available
- (developer, added) a 4th example host code in C++ showing how to embed
  ChucK core as a component inside a host C++ program and get shred info
    example-4-shreds.cpp (working with shreds and VM msg queue)
- (updated, developer) WebChucK API expansion including the following
  methods available in javascript that calls down to ChucK core:
    chuck.now()
    void chuck.setParamInt( string, number )
    void chuck.setParamFloat( string, number )
    void chuck.setParamString( string, string )
    number chuck.getParamInt( string )
    number chuck.getParamFloat( string )
    string chuck.getParamString( string )
- (updated, developer) VM instruction dump (through +d flag) now
    prints control structures and other statements
===
WebChucK/IDE-- a number of UI updates with underlying VM support:
    https://chuck.stanford.edu/ide/
    https://chuck.stanford.edu/webchuck/
===
miniAudicle (macOS) critical install bug (which affects those who 
installed chuck-1.5.0.5 through 1.5.0.7 on macOS) is now addressed, if 
you are experiencing strangeness with opening CK files, try this 
troubleshooting recommendation:
    https://chuck.stanford.edu/release/images/mA-install-duplicate.jpg


1.5.0.7 (July 2023)
=======
(note) this patch release contains general internal maintenance for 
  developers; it also accompanies a critical bug fix in miniAudicle

- (update/fixed) now --version and --about command-line flags will
  correctly print all available audio drivers options, e.g.,
  ```
  chuck version: 1.5.0.7-dev (chai)
     macOS | 64-bit
     audio driver: CoreAudio
     http://chuck.cs.princeton.edu/
     http://chuck.stanford.edu/
  ```
  ```
  > chuck --version
  chuck version: 1.5.0.7 (chai)
     Linux | 64-bit
     audio drivers: ALSA | PulseAudio | JACK
     http://chuck.cs.princeton.edu/
     http://chuck.stanford.edu/
  ```
  ```
  > chuck --version
  chuck version: 1.5.0.7 (chai)
     Microsoft Windows | 64-bit
     audio drivers: ASIO | DirectSound | WASAPI
     http://chuck.cs.princeton.edu/
     http://chuck.stanford.edu/
  ```
- (developer, updated) internal streamlining of chuck core, which is
  now completely decoupled from knowledge of system audio I/O;
  this makes chuck core cleaner, more portable, and easier to integrate
  as a component
- (developer, added) examples hosts code in C++ showing how to embed
  ChucK core as a component inside a host C++ program:
  src/host-examples/
  example-1-minimal.cpp (no real-time audio)
  example-2-audio.cpp (real-time audio)
  example-3-globals.cpp (communication between C++ and ChucK)
- (developer, added) chuck core can now be built without specifying
  additional macros, added new core build flavor: 'vanilla'
  ```
  src/core> make vanilla
  ```
  Builds all source inside src/core, no flags and no linking
  (The vanilla build is not intended for production but for development.)
- (developer, updated) internal cleanup of platform macros:
  __PLATFORM_APPLE__
  __PLATFORM_LINUX__
  __PLATFORM_WINDOWS__
  __PLATFORM_EMSCRIPTEN__
  __PLATFORM_ANDROID__
  (with additional sub-platform macros)


1.5.0.6 (July 2023)
=======
- (fixed, high priority) VM replace print crash
- (updated) VM operation message colors


1.5.0.5 (July 2023)
=======
- (added) color TTY support for command-line chuck is here! ChucK in
  color! compiler errors, probes, logs, on-the-fly programming (OTF),
  and other messages are now output in color, when chuck detects it is 
  outputting to a TTY (e.g., interactive terminal).
- (added) color TTY can can be explicitly enabled/disabled using
  --color and --no-color when running chuck on the command line
- (added) color TTY support for --verbose --probe and --chugin-probe
  ===
- (added) chuck compiler now highlights code when reporting 
  compiler errors, pinpointing the error location
  ```
  terminal> chuck test/06-Errors/error-no-memb2.ck
    error-no-memb2.ck:3:5: error: class 'SinOsc' has no member 'test'
    [3] foo.test();
            ^
  terminal> chuck test/06-Errors/error-syntax-1.ck
    error-syntax-1.ck:5:12: syntax error
    [5] */ it @ is not ! valid => syntax!
                   ^
  ```
- (added) error message when given a directory name instead of .ck file
  ```
  terminal> chuck myFolder
  [chuck]: cannot parse file: 'myFolder' is a directory
  ```
- (added) --disable-error-show-code command line flag to not print code 
  highlighting when reporting compiler errors this is a compatibility flag 
  and is mainly used for unit testing
  ===
- (updated) Machine.eval() execution semantics 
  *** NEW: Machine.eval() now will immediately spork and run
  the evaluated code as a new shred, and automatically yield the current 
  shred to give the new shred a chance to run, without advancing time.
  *** PREVIOUSLY: Machine.eval() sent an ADD message, this incurs a 
  one sample delay and does not run immediately
  ---
  For example, this one line program under the NEW behavior will print
  1 before "foo"; the PREVIOUS behavior would print "foo" first and will
  not print 1 until time is advanced by a > 0 amount
  ```
  Machine.eval( "<<< 1 >>>;" );
  <<< "foo" >>>;
  ```
- (updated) examples/machine/eval.ck -- updated to reflect the above
- (added) examples/machine/eval-global.ck -- shows the new Machine.eval()
  in action to synchronously modify a shared global variable
- (added) examples/machine/version.ck -- ever wonder which chuck language
  version you are currently using?
- (added) scientific notations for floating point
  <<< 123e4 >>>; // prints 1230000.000000 :(float)
- (added) hexidecimal float literals
  <<< 0x1p-4 >>>; // prints 0.062500 :(float)
- (updated) chugins with errors during query are no longer loaded,
  and is more clearly reported (LOG level -v3 or above)
- (updated) more robust parsing of code literals
- (updated, developer) repaying ancient debt -- AST tree cleanup
- (updated, developer) reworking chuck_vm_debug system
- (updated, developer) renaming global names CK_* or ck_* to minimize 
  conflict when using chuck-core as component


1.5.0.4 (June 2023)
=======
- (added) Math.randomize() -- implicitly randomize RNG seed
  ---
  "Randomize the seed of the random number generator (RNG), using an
   non-deterministic mechanism. Whereas srandom() explicitly seeds the
   RNG and will produce a deterministic sequence of pseudo-random
   numbers, randomize() "shakes things up" and causes RNG to start
   generating from a practically unpredicable seed. The quality of
   randomize() depends on the underlying implementation."
- (added) examples
    |- math/randomize.ck -- shows Math.randomize() in action
    |- math/maybe.ck -- can't decide? flip a coin with maybe
    |- math/int-dist.ck -- simulates distribution of Math.random2()
- (updated) improved RNG behavior that probably no one will notice
- (fixed) assignments into a full array declaration now results in a
  compiler error (previously this would cause a crash). for example:
  === code ===
    [1,2] @=> int foo[2];
  === resulting compiler error ===
    cannot assign '@=>' to full array declaration...
      |- hint: declare right-hand-side as empty array
      |- e.g., int foo[]
- (note) as before, assignments into a full non-array declaration still 
  works, effectively treating the right-hand-side declaration as a 
  reference:
  === code ===
    // effective same as new Object @=> Object @ foo;
    // works as before
    new Object @=> Object foo;
- (added) --chugin-probe command-line flag to probe (and verify version)
  for chugins and auto-load chuck sources in the search paths; print 
  results and any version mismatches (e.g., `chuck --chugin-probe`)
  also, explicited named chugins can be probed using --chugins:[FILE]
  (e.g., `chuck --chugin:Foo.chug --chugin:Bar.chug --chugin-probe`) 
- (added) chugins loading in search directories now will recursively
  search in subdirectories
- (added, macOS + Linux) ~/.chuck/lib added to the list of default
  search directories; this makes it easier to locally install/organize
  chugins (and auto-load .ck files) without administrator privilege
  ---
  macOS
    /usr/local/lib/chuck
    /Library/Application Support/ChucK/chugins
    ~/Library/Application Support/ChucK/chugins
    ~/.chuck/lib
  Linux
    /usr/local/lib/chuck
    ~/.chuck/lib
  Windows
    C:\Windows\system32\ChucK
    C:\Program Files\ChucK\chugins
    C:\Program Files (x86)\ChucK\chugins
    C:\Users\%USERNAME%\Documents\ChucK\chugins
  ---
- (updated) chuck --verbose output now streamlined and more effectively
  describes what is happening under-the-hood; e.g.,
    `chuck [FILENAMES] -v2` to see SYSTEM output
    `chuck [FILENAMES] -v5` to see INFORM output
    `chuck [FILENAMES] -v10` to see ALL!!! output
- (updated) setting chuck log level is no longer logged below INFORM
  log-level
- (fixed, developer) distinct notions of base type reference and array 
  reference; for example SinOsc @ foo[] -> `SinOsc @` is base type 
  reference and `foo[]` is array reference
- (fixed, developer) instruction dumps (via +d flag) more correctly
  prints reference-related (@) declarations and new operations


1.5.0.3 (June 2023)
=======
- (fixed) chuck audio I/O now correctly carries out extended probing
  for default input and output devices with differing sample rates,
  e.g., with some bluetooth mic/headphones whose input is limited
  to 24kHZ, including some AirPods.
- (note) beyond the above, this release is a follow-up maintenance
  release; please see 1.5.0.1 and earlier release notes  to see recent
  feature updates
- (updated) examples/README now has more useful information
- (updated) README.md streamlined and linux build instructions improved.
- (updated, developer) `make linux-all` (or simply `make linux`) now
  builds all supported drivers (e.g., ALSA, PulseAudio, JACK); this is
  equivalent in outcome to `make linux-alsa linux-pulse linux-jack`
- (updated, developer) makefile streamlined


1.5.0.2 (June 2023)
=======
(note) this is primarily a maintenance release; please see 1.5.0.1
  and earlier release notes  to see recent feature updates

- (fixed) (jack, linux/unix) port name now accounts for regex meta
  characters (thanks @gyroplast and @garyscavone)
- (developer) house cleaning on the chuck git repository
  |- migrated large files out of 'chuck' and into a new 'chuck-media' repo
  |- streamlined release notes and moved to top level
  |- removed outdated files
  |- added additional information including ChucK History into README.md
-- NOTE TO DEVELOPERS --
  The Great ChucK Repo Cleanup of 2023 has been completed! As a 
result, the overall chuck repo size has been reduced from 721MB to 
25MB. Since git works by cloning the entire repo and all history, this 
massively improves the speed of git clone, git submodule update --init in 
repos that reference chuck, and the size of each chuck clone on disk. 
  To accomplish this, we had to "rewrite the git history," which is 
a semi-cataclysmic process for git repos. As a result, all existing 
clones of the chuck, miniAudicle, and chunity repos as well as branches 
and pull-requests that reference the older repo *** are now invalid ***. 
Please do a fresh clone of the chuck/miniAudicle/chunity repos and copy 
any important changes to these fresh clones before making any further 
changes to avoid headaches! 
  NOTE: do not use git pull with your existing, pre-cleanup chuck 
repo as it will seem to work BUT will put your local repo into a messed 
up state. A fresh git clone is necessary before proceeding with chuck 
development! We believe that the cleaner, smoother ChucK dev experience 
will be worth this short-term inconvenience. Apologies for any confusion 
that may arise, and thank you for being involved in ChucK development!
  A "legacy" pre-cleanup fork of the repository before the Cleanup
has been archived here: https://github.com/spencersalazar/chuck-legacy
---
miniAudicle (added: few helpful features)
- (added) menu "Help" now has items that will open websites in
  the default browser:
  "ChucK Class Library Reference..."
    https://chuck.stanford.edu/doc/reference/
  "ChucK Documentation..."
    https://chuck.stanford.edu/doc/
  "ChucK Community..."
    https://chuck.stanford.edu/community/
- (updated) menu "Help" now correctly directs user to miniAudicle
  and ChucK websites:
  "ChucK website..."
    https://chuck.stanford.edu/
  "miniAudicle website..."
    https://github.com/ccrma/miniAudicle/
- (added, Windows/Linux) Device Browser now has an "Audio driver"
  drop-down box that can select an available driver to view its
  associated audio devices


1.5.0.1 (June 2023)
=======
- (added) WvOut support for multiple bit-depths: 16-bit signed int,
  24-bit signed int, 32-bit signed int, 32-bit float, 64-bit float
- (added) the above can be optionally specified in new overloaded WvOut methods:
	string aifFilename( string value, int datatype );
	    Open an AIFF file for writing, with datatype (e.g., IO.INT16,
	    IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).
	string sndFilename( string value, int datatype );
	    Open SND file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32,
	    IO.FLOAT32, IO.FLOAT64).
	string wavFilename( string value, int datatype );
	    Open WAVE file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).
	string matFilename( string value, int datatype );
	    Open MATLAB file for writing; NOTE: datatype for MATLAB files can
	    only be IO.FLOAT64.
	string rawFilename( string value, int datatype );
	    Open a RAW file for writing; NOTE: datatype for raw files can
	    only be IO.INT16
- (added) examples/stk/wvout-24bit.ck shows writing to a 24-bit audio file
- (added) new IO flags: IO.INT24, IO.INT64, IO.FLOAT32, IO.FLOAT64
  IO.UINT8, IO.SINT8, IO.UINT16, IO.SINT16, IO.UINT32, IO.SINT32,
  IO.UINT64, IO.SINT64
- (fixed) (Windows) HID joystick input
    |- note: certain joystick devices (including some XBox One gamepads)
       are recognized but do not receive input data; a workaround is to
       install explicitly HID drivers for these devices; see
    |- https://www.snes9x.com/phpbb3/viewtopic.php?t=27510&sid=661fbbc1609037a8ec2e5f10e003f5a0
    |- (from above URL): open Device Manager, expand "Human Interface Devices",
          right click "XINPUT compatible HID device", "Update driver",
       "Browse my computer", "Let me pick". should be three options.
       Try "HID-compliant game controller". If you want to undo the
       change, same thing but update "HID-compliant game controller"
       and pick the XINPUT ***
- (updated) BINARY mode for IO now able to read signed vs. unsigned integers,
  specified using using .readtInt( flags ), where 'flags' is one of the above
  IO flags; in BINARY mode, IO.INT8/16/32 now returns unsigned integers, same as
  IO.UINT8/16/32; to read in signed two's complement integers, use the new
  IO.SINT8/16/32/64 flags
- (added) FileIO.readFloat( int flags) and FileIO.write( float val, int flags )
  these overloaded versions of readFloat() and write() respectively have a 'flags'
  argument to specify the kind of float (IO.FLOAT32 or IO.FLOAT64)
- (added) examples/io/read-wav-raw.ck -- illustrates directly parsing a WAV file
  using FileIO in binary mode (author: Perry R. Cook)
- (added) examples/special/scream-o-matic/ -- using LiSa + granular
  synthesis for a scream texture generator.
- (fixed) potential-crash-on-shutdown type system issue
- (fixed) CNoise incorrect bias on pink noise (thank you anthonyhawes)
- (updated) on all platforms, Math.random*() functions now internally
  use a standard Mersenne Twister RNG (mt19937); this greatly improves 
  the quality of RNG output, especially on Windows
- (updated) on Linux, better default runtime driver selection for
  Jack and ALSA
- (updated/developer) chuck core minimum c++ level raised to c++11;
  projects need compile chuck core with earlier dialect of c++ would need
  to modify the source code accordingly
- (updated/developer) makefile for linux-jack
- (updated/developer) migrated RegEx module from base chuck to chugin
- (added/developer) DL Api array4 operations from chugin
- (added/developer) ChuckArray4::contains_object() returns whether
  array4 contains object references or integers
---
miniAudicle
- (updated) on Windows and Linux; miniAudicle now has a "Audio driver"
  drop-down selection in the Preferences dialog window; this selections
  allows for run-time selection of different drivers, e.g., "DirectSound",
  "WASAPI", or "ASIO" on Windows, as well as "Jack", "Pulse", or "ALSA" on
  Linux
- (fixed) miniAudicle linux compilation using Qt6
    |- FYI: needs qscintilla-qt6-devel and qscintilla-qt6)
  [Many thanks to Fernando Lopez-Lezcano and Nils Tonn??tt]


=======
1.5.0.0 (May 2023)
=======
***************************************************************************
* chuck-1.5.0.0 (chai)
***************************************************************************
* significant addition: ChAI (Chuck + AI)
* significant update: WebChucK (ChucK in web browser) + WebChucK IDE
* also: new features, new bug fixes, and new bugs!
***************************************************************************
(NOTE) WebChucK (ChucK on browsers) [beta] was released during the 
development of this version.

WebChucK IDE (program chuck on the web):
https://chuck.stanford.edu/ide/

WebChucK landing page (including using WebChucK in your web projects)
https://chuck.stanford.edu/webchuck/
---
(NOTE) ChAI (ChucK + AI), first appeared in beta as part of chuck-1.4.2.0;
ChAI was used in the course Music 356 / CS 470 "Music and AI" [*] at
Stanford University, taught by Ge Wang and Yikai Li (TA); Many thanks to
the immensely creative students of "Music and AI". The v1.0 version of the
ChAI API and modules is hereby released, with new additions on the way.

ChAI landing page:
https://chuck.stanford.edu/chai/

"Music and AI" (Winter 2023 Stanford University) -- taught with ChAI
https://ccrma.stanford.edu/courses/356-winter-2023/
---
(HISTORICAL NOTE for ChAI)
Much of ChAI and its ways of thinking and doing can be foundationally
attributed to the work of Dr. Rebecca Fiebrink, her landmark Ph.D. Thesis,
/Real-time Human Interaction With Supervised Learning Algorithms for Music
Composition and Performance/ (2011) [1], the Wekinator framework [2], her
teaching at the intersections of AI, HCI, and Music [3], as well as earlier
collaborations between Rebecca and Ge [4,5] including SMIRK [6] (Small Musical
Information Retrieval toolKit; 2008; MARSYAS and the MIR work of Dr. George
Tzanetakis; early efforts in on-the-fly learning), the unit analyzer
framework [7] (2007; afford real-time audio feature extraction). All of
these have directly or indirectly contributed the creation of ChAI.
Additionally, ChAI benefitted from the teaching and design philosophy of
Dr. Perry R. Cook (Ph.D. advisor to Rebecca, George, and Ge at Princeton,
and ChucK co-author), who argued for real-time human interaction, parametric
sound synthesis, and the importance of play in the design of musical tools.

[1] Fiebrink, Rebecca. 2011. /Real-time Human Interaction With Supervised
Learning Algorithms for Music Composition and Performance/ Ph.D. Thesis.
Princeton University. https://www.cs.princeton.edu/techreports/2010/891.pdf
[2] http://www.wekinator.org/
Wekinator | Software for real-time, interactive machine learning
[3] Fiebrink, Rebecca. "Machine Learning for Musicians and Artists" MOOC
https://www.kadenze.com/courses/machine-learning-for-musicians-and-artists/info
[4] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Foundations for On-the-fly
Learning in the ChucK Programming Language." /International Computer Music
Conference/. https://mcd.stanford.edu/publish/files/2008-icmc-learning.pdf
[5] Fiebrink, R., G. Wang, P. R. Cook. 2008. "Support for Music Information
Retrieval in the ChucK Programming Language." /International Conference
on Music Information Retrieval/ (ISMIR).
https://mcd.stanford.edu/publish/files/2008-ismir-proto.pdf
[6] http://smirk.cs.princeton.edu/
sMIRk | Small Music Information Retrieval toolKit
[7] Tzanetakis, G. and P. R. Cook. 2000 "MARSYAS: A Framework for Audio
Analysis." Organised Sound. 4:(3)
[8] Tzanetakis, G. and P. R. Cook. 2002 "Musical Genre Classification of
Audio Signals." IEEE Transaction on Speech and Audio Processing. 10(5).
[9] Wang, G., R. Fiebrink, P. R. Cook. 2007. "Combining Analysis and
Synthesis in the ChucK Programming Language." /International Computer
Music Conference/. https://mcd.stanford.edu/publish/files/2007-icmc-uana.pdf
---
- (added) Wekinator [ChAI] (thanks Rebecca Fiebrink and Yikai Li)
    |- A Wekinator utility that maps input vectors to output vectors,
       commonly used for interactive machine learning combining
       human-computer interaction and ML. Based on Rebecca Fiebrink's
       Wekinator framework.
    |- (inheritance) Wekinator -> Object
    -------------------
	void add();
	    Add current inputs and outputs to the observations.
	void add( float[] inputs, float[] outputs );
	    Add given inputs and outputs to the observations.
	void add( int output_index, float[] inputs, float[] outputs );
	    Add given inputs and outputs to the observations for the specified output.
	void clear();
	    Clear everything except the global properties.
	void clearAllObs();
	    Clear all observations.
	void clearAllObs( int output_index );
	    Clear all observations for the specified output.
	void clearObs( int lo, int hi );
	    Clear the observations by id range.
	void clearObs( int output_index, int lo, int hi );
	    Clear the observations by id range for the specified output.
	void deleteLastRound();
	    Delete the last round of observations.
	void exportObs( string filename );
	    Export the observations to a file.
	void exportObs( int output_index, string filename );
	    Export the observations for the specified output to a file.
	int getAllRecordStatus();
	    Get the record status for all outputs.
	int getAllRunStatus();
	    Get the run status for all outputs.
	void getObs( float[][] obs );
	    Get the observations in the Wekinator.
	void getObs( int output_index, float[][] obs );
	    Get the observations for the specified output in the Wekinator.
	void getOutputProperty( int output_index, string property_name, int[] property_value );
	    Get the output property of the Wekinator. See the Wekinator documentation for more information.
	float getOutputPropertyFloat( int output_index, int property_type, string property_name );
	    Get the output property of the Wekinator. See the Wekinator documentation for more information.
	int getOutputPropertyInt( int output_index, string property_name );
	    Get the output property of the Wekinator. See the Wekinator documentation for more information.
	int getOutputPropertyInt( int output_index, int property_type, string property_name );
	    Get the output property of the Wekinator. See the Wekinator documentation for more information.
	int getOutputRecordStatus( int output_index );
	    Get the record status for the specified output.
	int getOutputRunStatus( int output_index );
	    Get the run status for the specified output.
	float getPropertyFloat( int property_type, string property_name );
	    Get the property of the Wekinator. See the Wekinator documentation for more information.
	int getPropertyInt( int property_type, string property_name );
	    Get the property of the Wekinator. See the Wekinator documentation for more information.
	int getRound();
	    Get the current recording round.
	void importObs( string filename );
	    Import the observations from a file.
	void input( float[] inputs );
	    Set the inputs of the Wekinator.
	int inputDims( int n );
	    Set the number of input dimensions to Wekinator.
	int inputDims();
	    Get the number of input dimensions to Wekinator.
	void load( string filename );
	    Load the Wekinator from a file.
	int modelType( int model_type );
	    Set the model type of the Wekinator. Options: AI.Regression: AI.MLP, AI.LR,
	    AI.Classification: AI.KNN, AI.SVM, AI.DT
	int modelType();
	    Get the model type id of the Wekinator.
	string modelTypeName();
	    Get the model type name of the Wekinator.
	void nextRound();
	    Bump the recording round.
	int numObs();
	    Get the number of observations in the Wekinator.
	int numObs( int output_index );
	    Get the number of observations for the specified output in the Wekinator.
	void output( float[] outputs );
	    Set the outputs of the Wekinator.
	int outputDims( int n );
	    Set the number of output dimensions to Wekinator.
	int outputDims();
	    Get the number of output dimensions to Wekinator.
	void predict( float[] inputs, float[] outputs );
	    Predict outputs for the given inputs.
	void randomizeOutputs();
	    Randomize the outputs of the Wekinator.
	void save( string filename );
	    Save the Wekinator to a file.
	void setAllRecordStatus( int status );
	    Set the record status for all outputs.
	void setAllRunStatus( int status );
	    Set the run status for all outputs.
	void setOutputProperty( int output_index, string property_name, int property_value );
	    Set the output property of the Wekinator. See the Wekinator documentation for more information.
	void setOutputProperty( int output_index, int property_type, string property_name, int property_value );
	    Set the output property of the Wekinator. See the Wekinator documentation for more information.
	void setOutputProperty( int output_index, int property_type, string property_name, float property_value );
	    Set the output property of the Wekinator. See the Wekinator documentation for more information.
	void setOutputProperty( int output_index, string property_name, int[] property_value );
	    Set the output property of the Wekinator. See the Wekinator documentation for more information.
	void setOutputRecordStatus( int output_index, int status );
	    Set the record status for the specified output.
	void setOutputRunStatus( int output_index, int status );
	    Set the run status for the specified output.
	void setProperty( int property_type, string property_name, int property_value );
	    Set the property of the Wekinator. See the Wekinator documentation for more information.
	void setProperty( int property_type, string property_name, float property_value );
	    Set the property of the Wekinator. See the Wekinator documentation for more information.
	int taskType( int task_type );
	    Set the task type of the Wekinator. Options: AI.Regression, AI.Classification
	int taskType();
	    Get the task type id of the Wekinator.
	string taskTypeName();
	    Get the task type name of the Wekinator.
	void train();
	    Train models for all outputs.
- (added) new examples in ai/wekinator [ChAI]
    |- wekinator-basic.ck -- example of basic Wekinator usage
    |- wekinator-custom.ck -- more extensive customization for Wekinator
    |- wekinator-import.ck -- example of importing observations from file
- (added) MLP [ChAI] (thanks Yikai Li)
    |- a multilayer perceptron (MLP)--a basic artificial neural 
       network--that maps an input layer to an output layer across a 
       number of fully-connected hidden layers. This implementation can be 
       trained either 1) by using one of the comprehensive .train() 
       functions OR 2) by iteratively calling .forward() and .backprop() 
       for each input-output observation, and using .shuffle() for each 
       epoch. Commonly used for regression or classification.
    |- (inheritance) MLP -> Object
    -------------
    void backprop( float[] output, float learningRate );
        (Manually) backpropagate from the output layer, for a single input-output
        observation; compute the gradient of the loss function with respect to
        the weights in the network, one layer at a time.
    void forward( float[] input );
        (Manually) forward-propagate the input vector through the network.
    void getActivations( int layer, float[] activations );
        Get the activations of the given layer, after a manual .forward().
    void getBiases( int layer, float[] biases );
        Get the biases of the given layer.
    void getGradients( int layer, float[] gradients );
        Get the gradients of the given layer, after a manual .backprop().
    int getPropertyInt( int modelType, string key );
        Get int property of name 'key' for the given model type (options: AI.MLP, AI.KNN, AI.SVM).
    float getPropertyFloat( int modelType, string key );
        Get float property of name 'key' for the given model type (options: AI.MLP, AI.KNN, AI.SVM).
    void getWeights( int layer, float[][] weights );
        Get the weights of the given layer.
    void init( int[] unitsPerLayer );
        Initialize the MLP with the given number of neurons per layer, as
        specified in 'unitsPerLayer'.
    void init( int[] nodesPerLayer, int[] activationPerLayer );
        Initialize the MLP with the given number of nodes per layer and the given
        ctivation function per layer, as specified in 'activationPerLayer'
        (options: AI.Linear, AI.Sigmoid, AI.ReLU, AI.Tanh, or AI.Softmax).
    void init( int[] nodesPerLayer, int activationFunction );
        Initialize the MLP with the given number of nodes per layer and the given
        activation function for all layers (options: AI.Linear, AI.Sigmoid, 
        I.ReLU, AI.Tanh, or AI.Softmax).
    int load( string filename );
        Load a MLP model from file.
    int predict( float[] input, float[] output );
        Predict the output layer from an input layer.
    void setProperty( int modelType, string key, int value );
        Set int property of name 'key' for the given model type (options: AI.MLP, AI.KNN, AI.SVM).
    void setProperty( int modelType, string key, float value );
        Set float property of name 'key' for the given model type (options: AI.MLP, AI.KNN, AI.SVM).
    int save( string filename );
        Save the MLP model to file.
    void train( float[][] inputs, float[][] outputs );
        Train the MLP with the given input and output observations with default
        learning rate=.001 and epochs=100.
        (Also see MLP.train(inputs,outputs,learningRate,epochs).)
    void train( float[][] inputs, float[][] outputs, float learningRate, int epochs );
        Train the MLP with the given input and output observations, the learning
        rate, and number of epochs.
    static void shuffle( float[][] X, float[][] Y );
        (Manually) shuffle the given input and output vectors.
- (added) new examples in ai/mlp [ChAI]
    |- mlp.ck -- example training a basic artificial neural network
    |- mlp-manual.ck -- example of step-by-step training an MLP, printing each stage
    |- mlp-load.ck -- loading a saved MLP model from file
    |- mlp-save.ck -- saving the MLP model to file'
    |- model.txt -- an example model file
- (added) Word2Vec [ChAI] (thanks Yikai Li)
    |- A word embeddings utility that maps words to vectors; can load a 
       model and perform similiarity retrieval.
    |- (inheritance) Word2Vec -> Object
    ------------------
    int contains( string word );
        Query if 'word' is in the current model.
    int dim();
        Get number of dimensions for word embedding.
    void getSimilar( string word, int k, string[] output );
        Get the k most similar words to the given word.
    void getSimilar( float[] vec, int k, string[] output );
        Get the k most similar words to the given vector.
    void getVector( string word, float[] output );
        Get the vector of the given word.
    int load( string path );
        Load pre-trained word embedding model from the given path.
    int load( string path, int useKDTreeDim );
        Load pre-trained word embedding model from the given path; will use 
        KDTree for similarity searches if the data dimension is less than 
        or equal to 'useKDTreeDim'. Set 'useKDTreeDim' to 0 to use linear 
        (brute force) similarity search; set 'useKDTreeDim' to less than 0 
        to always use KDTree.
    void minMax( float[] mins, float[] maxs );
        Retrieve the minimums and maximums for each dimension.
    int size();
        Get number of words in dictionary.
    int useKDTree();
        Get whether a KDTree is used for similarity search.
- (added) new examples in ai/word2vec [ChAI]
    |- poem-i-feel.ck -- a stream of unconsciousness poem generator
    |- poem-randomwalk.ck -- another stream of unconsciousness generator
    |- poem-spew.ck -- yet another stream of unconsciousness generator
    |- poem-ungenerate.ck -- interactive prompt un/de-generator
       (need to use command line chuck)
    |- word2vec-basic.ck -- demos load(), getVector(), getSimilar()
    |- word2vec-prompt.ck -- command line interactive tool
       (need to use command line chuck)
- (added) Chroma unit analyzer (thanks Yikai Li)
    |- A unit analyzer that computes pitch chroma
    |- see examples/ai/features/chroma.ck
- (added) Kurtosis unit analyzer (thanks Yikai Li)
    |- A unit analyzer that computes kurtosis
    |- see examples/ai/features/kurtosis.ck
- (added) SFM unit analyzer (thanks Yikai Li)
    |- A unit analyzer that computes spetral flatness measure
    |- see examples/ai/features/sfm.ck
- (moved) examples/analysis/features => examples/ai/features
- (added) new examples in examples/ai/features
    |- features-combined -- real-time extraction of multiple features
    |- mfcc-basic.ck -- shows MFCC unit analyzer / feature extractor
    |- mfcc-mean.ck -- averaged MFCC feature extraction
    |- chroma.ck -- shows Chroma unit analyzer
    |- kurtosis.ck -- shows Kurtosis unit analyzer
    |- sfm.ck -- shows SFM (spectral flatness measure) unit analyzer
- (added) PCA [ChAI] (thanks Yikai Li)
    |- A principle component analysis (PCA) utility, commonly used
       for dimensionality reduction.
    |- (inheritance) PCA -> Object
    -------------------
    static void reduce( float[][] input, int D, float[][] output );
        Dimension-reduce 'input' (NxM) to 'output' (NxD) as the projection
        of the input data onto its first 'D' principle components
- (added) example: ai/pca/pca.ck
- (reworked) KNN [ChAI] (thanks Yikai Li)
    |- A basic k-NN utility that searches for k nearest
       neighbors from a set of observations / feature
       vectors. (Also see KNN2. The differrence between KNN
       and KNN2 is that KNN does not deal with labels whereas
       KNN2 is designed to work with labels.)
    |- (inheritance) KNN -> Object
    -------------------
    void search( float[] query, int k, int[] indices );
        Search for the 'k' nearest neighbors of 'query' and
        return their corresponding indices.
    void search( float[] query, int k, int[] indices,
                 float[][] observations );
        Search for the 'k' nearest neighbors of 'query' and
        return their corresponding indices and observations
    int train( float[][] x );
        Train the KNN model with the given observations 'x'
    void weigh( float[] weights );
        Set the weights for each dimension in the data.
- (added) KNN2 [ChAI] (thanks Yikai Li)
    |- A k-NN utility that predicts probabilities of class
       membership based on distances from a test input to its
       k nearest neighbors. (Also see KNN. The differrence
       between KNN and KNN2 is that KNN does not deal with
       labels whereas KNN2 is designed to work with labels.)
    |- (inheritance) KNN2 -> Object
    -------------------
    int predict( float[] query, int k, float[] prob );
        Predict the output probabilities 'prob' given unlabeled test
        input 'query' based on distances to 'k' nearest neighbors.
    void search( float[] query, int k, int[] labels );
        Search for the 'k' nearest neighbors of 'query' and return
        their labels.
    void search( float[] query, int k, int[] labels, int[] indices );
        Search for the 'k' nearest neighbors of 'query' and return
        their labels and indices.
    void search( float[] query, int k, int[] labels, int[] indices,
                 float[][] observations);
        Search for the 'k' nearest neighbors of 'query' and return
        their labels, indices, and observations.
    int train( float[][] x, int[] labels );
        Train the KNN model with the given samples 'x' and
        corresponding labels.
    void weigh( float[] weights );
        Set the weights for each dimension in the data.
- (renamed) unit analyzer pilF is now UnFlip; pilF deprecated
- (added) example: ai/knn/knn-search.ck
- (added) example: ai/knn/knn2-classify.ck
- (added) example: ai/knn/knn2-search.ck
    --------------
- (updated) real-time audio backend has been updated
            *** thank you Dana Batali ***
- (added) all platform: driver support
- (added) Windows: ASIO, WASAPI, DirectSound
- (added) linux: now can build multiple drivers into single executable
          > make linux-pulse linux-alsa linux-jack
- (fixed) macOS bluetooth/Apple AirPods audio input device error;
    |- CONTEXT: Apple AirPods (and a number of other Bluetooth headphones) 
    show up in macOS as its own audio input device and supports only one 
    sample rate (24K in the case of AirPods). ChucK, like most full-duplex 
    audio software, requires matching sample rates for audio input and 
    output. By default, it would try to initialize with a sample rate of 
    44.1K or 48K and would fail initialization due to the rate mismatch 
    with the AirPods.
    |- FIX: ChucK now has additional logic when initializing default audio 
    devices, and will automatically try to match with a different input 
    devices when needed.
- (fixed) VM timing issue when real-time audio initialization switches to 
    a different sample rate when the requested/default sample rate is not
    available
- (added) new default duration 'eon' == day * 365.256363004 * 1000000000.0 (thanks nshaheed)
    example: eon => now; // a long long time from now
- (added) new static method for all Objects
      Type Object.typeOf()
          Get the type of this object (or class).
- (added) new Type type
    |- A representation of a ChucK type.
    |- (inheritance) Type -> Object
    --------------
    int arrayDepth();
        Return the number of array dimensions associated with this Type (e.g., 'int[][]' has 2; 'int' has 0).
    Type[] children();
        Retrieve this Type's children Types.
    int equals( Type another );
        Return whether this Type is same as 'another'.
    int isArray();
        Return whether this Type is some kind of an array.
    int isPrimitive();
        Return whether this is a primitive Type (e.g., 'int' and 'dur' are primitives types; 'Object' and its children Types are not).
    int isa( Type another );
        Return whether this Type is a kind of 'another'.
    int isa( string another );
        Return whether this Type is a kind of 'another'.
    string name();
        Return the name of this Type.
    string baseName();
        Return the base name of this Type. The base of name of an array Type is the type without the array dimensions (e.g., base name of 'int[][]' is 'int')
    string origin();
        Return a string describing where this Type was defined (e.g., "builtin", "chugin", "cklib", "user").
    Type parent();
        Return this Type's parent Type; returns null if this Type is 'Object'.
    static Type find( string typeName );
        Find and return the Type associated with 'typeName'; returns null if no Types currently in the VM with that name.
    static Type[] getTypes( int attributes, int origins );
        Retrieve all top-level Types in the ChucK runtime type system that fit the attributes and origins flags. Flags that can bitwise-OR'ed for attributes: Type.ATTRIB_OBJECT, Type.ATTRIB_PRIMITIVE,  TYPE_SPECIAL -- and for origins: Type.ORIGIN_BUILTIN, Type.ORIGIN_CHUGIN, Type.ORIGIN_CKLIB, Type.ORIGIN_USER.
    static Type[] getTypes();
        Retrieves all top-level Types currently in the type system.
    static Type of( Object obj );
        Return the Type of 'obj'
    static Type of( int val );
        Return the Type associated with 'int'.
    static Type of( float val );
        Return the Type associated with 'float'.
    static Type of( time val );
        Return the Type associated with 'time'.
    static Type of( dur val );
        Return the Type associated with 'dur'.
    static Type of( complex val );
        Return the Type associated with 'complex'.
    static Type of( polar val );
        Return the Type associated with 'polar'.
    static Type of( vec3 val );
        Return the Type associated with 'vec3'.
    static Type of( vec4 val );
        Return the Type associated with 'vec4'.
    --------------
    static int ATTRIB_OBJECT;
        Attribute bit for non-primitive Object types.
    static int ATTRIB_PRIMITIVE;
        Attribute bit for primitive types.
    static int ATTRIB_SPECIAL;
        Attribute bit for special types (e.g., @array and @function).
    static int ORIGIN_BUILTIN;
        Origin bit for "builtin".
    static int ORIGIN_CHUGIN;
        Origin bit for "chugin".
    static int ORIGIN_CKLIB;
        Origin bit for "cklib".
    static int ORIGIN_USER;
        Origin bit for "user".
- (added) new examples in examples/type
    |- polymorph.ck -- an example of polymorphism in ChucK
    |- type_query.ck -- querying for a list of types from the ChucK runtime type system
    |- type_type.ck -- example showing some functionalities of the Type type
    ---------------
- (added) new CKDoc class
    |- A ChucK documentation generator. Based on Spencer Salazar's ckdoc utility.
    |- (inheritance) CKDoc -> Object
    ---------------
    void addGroup( Type[] types, string name, string shortName, string description );
        Add a group of types to be documented, including group 'name', a 'shortName' to be used for any files, and a group 'description'.
    void addGroup( string[] typeNames, string name, string shortName, string description );
        Add a group of types (by type name) to be documented, including group 'name', a 'shortName' to be used for any files, and a group 'description'.
    void clear();
        Clear all added groups.
    string examplesRoot( string path );
        Set the examples directory root path; returns what was set.
    string examplesRoot();
        Get the current examples directory root path.
    string genCSS();
        Generate CSS; return as string.
    void genGroups( string[] results );
        Generate documentation for all added groups, return each in a separate entry
    string genIndex( string indexTitle );
        Generate top-level index; return as string.
    string genType( Type type );
        Generate documentation for a single Type.
    string genType( string typeName );
        Generate documentation for a single Type (by name).
    int numGroups();
        Get the number of groups added.
    int outputFormat( int which );
        Set which output format to use; see CKDoc.HTML, CKDoc.TEXT, CKDoc.MARKDOWN, CKDoc.JSON.
    int outputFormat();
        Set which output format is selected; see CKDoc.HTML, CKDoc.TEXT, CKDoc.MARKDOWN, CKDoc.JSON.
    int outputToDir( string path, string indexTitle );
        Generate everything as files into the output directory.
    static int HTML;
        Output HTML format.
    static int JSON;
        Output JSON format (not implemented).
    static int MARKDOWN;
        Output MARKDOWN format (not implemented).
    static int NONE;
        No output format.
    static int TEXT;
        Output TEXT format (not implemented).
    ---------------
- (added/updated) now ChucK API reference documentation is generated from
    the type system using CKDoc, ensuring alignment between documention
    and type system.
- (added) array.zero()
    |- zero out the contents of the array; size is unchanged.
- (added) negative indexing for arrays (thanks nshaheed)
    |- [1,2,3,4] @=> int a[]; a[-1]; // evaluates to 4
- (added) array.shuffle()
    |- shuffle the contents of the array.
- (added) example: array/array_negative.ck
- (added) example: array/array_shuffle.ck
- (added) example: array/array_zero.ck
- (updated) LiSa (all channel variants) internal restructure to allow
    for more flexible usage patterns | also # voices defaults to 16
- (added) example: special/LiSa-stereo.ck
- (added) Math functions
    float map( float value, float x1, float y1,
                            float x2, float y2 );
        Map 'value' from range [x1,y1] into range [x2,y2]; 'value'
        can be outside range[x1,y1].
    float map2( float value, float x1, float y1,
                             float x2, float y2 );
        Map 'value' from range [x1,y1] into range [x2,y2]; 'value'
        will be clamped to [x1,y1] if outside range.
        (Math.remap() is the same as Math.map2())
    float clampi( int value, int min, int max );
        Clamp integer 'value' to range [min, max].
    float clampf( float value, float min, float max );
        Clamp float 'value' to range [min, max].
    float cossim( float[] a[], float[] b[] );
        Compute the cosine similarity between arrays a and b.
    float cossim( vec3 a, vec3 b );
        Compute the cosine similarity between 3D vectors a and b.
    float cossim( vec4 a, vec4 b );
        Compute the cosine similarity between 4D vectors a and b.
    float euclidean( float[] a[], float[] b[] );
        Compute the euclidean distance between arrays a and b.
    float euclidean( vec3 a, vec3 b );
        Compute the euclidean distance between 3D vectors a and b.
    float euclidean( vec4 a, vec4 b );
        Compute the euclidean distance between 4D vectors a and b.
- (added) examples/math
    |- map.ck -- shows mapping using Math.map() and Math.map2()
    |- math-help.ck -- just prints Math API using Math.help();
- (added) Machine functions
    int eval( string code );
        Evaluate a string as ChucK code, compiling it and spork it as a child 
        shred of the current shred.
    int eval( string code, string args );
        Evaluate a string as ChucK code, with optional arguments (bundled in 
        'args' as "ARG1:ARG2:...", compiling it and spork it as a child shred of 
        the current shred.
    int eval( string code, string args, int count );
        Evaluate a string as ChucK code, with optional arguments (bundled in 
        'args' as "ARG1:ARG2:...", compiling it and sporking 'count' instances as 
        a child shreds of the current shred.
    int loglevel( int level );
        Set log level
          |- 0: NONE
          |- 1: CORE
          |- 2: SYSTEM
          |- 3: SEVERE
          |- 4: WARNING
          |- 5: INFO
          |- 6: CONFIG
          |- 7: FINE
          |- 8: FINER
          |- 9: FINEST
          |- 10: ALL
    static int loglevel();
        Get log level
- (added) examples in machine
    |- eval.ck -- demonstrate Machine.eval(), noting its behavior wrt 
       to schreduler
- (modified) MFCC -- added (back) a missing and crucial log10() to
    to the MFCC computation and updated implementation; output
    range magnitudes now in the hundreds
- (enhanced) overloaded functions with non-matching return types now
    provide additional information in the compiler error message
- (fixed) overloaded functions with identical arguments now will
    correctly result in a compiler error
- (fixed) attempting to assign to reserved/const values (e.g., 'day')
    now will correctly result in a compiler error
- (fixed, hopefully) no more LPF and HPF filter explosion for small 
    values of .freq (<.2), large values of .freq (>Nyquist frequency), 
    or Q < 1 with high frequency below Nyquist; now LPF.freq and HPF .Q 
    are internally clamped to values between [1,SRATE/2];
- (fixed) SndBuf crash in cases where file size is integer multiple
    of .chunks and .chunks > 0 and reaching the end of the file
- (fixed) SndBuf.valueAt(n) for n == file size in samples now returns 0;
    previously this special case returned .valueAt(n-1) 
- (fixed) SndBuf assertation failure if SndBuf.chunks was set AFTER
    loading a file; now .chunks will ONLY take effect for the next
    SndBuf.read
- (renamed) int LiSa.loop0(int) and int LiSa.loop0(); previously these
    were incorrectly overloaded as "loop()" and was unavailable
- (fixed) FileIO.seek() previously fails if EOF is reached in reading
    a file; FileIO.seek() now functions after EOF is reached.
- (fixed) FileIO.more() now looks ahead for EOF
- (updated) all cherr prints now flushes immediately
- (updated) IO.newline() or a solitary "\n" now automatically flushes
    chout
- (added) examples in examples/io
     |- read-byte.ck -- reading raw bytes from file in binary mode
     |- read-float.ck -- reading floats from file (in ASCII mode)
     |- seek.ck -- shows FileIO.seek usage for rewind a file read
     |- write-byte.ck -- writing raw bytes to file in binary mode
- (added) examples in examples/events
     |- event-x-bpm-1.ck -- example using custom Events to synchronize
        multiple shreds to a common clock
     |- event-x-bpm-2.ck -- same as event-x-bpm-2.ck but using arrays
- (added) absyn tree printing for instruction dumping abysn2str()
- (added) Machine.refcount() and refcount printing for object references
- (fixed) Stk WvIn, WvOut, and VoicForm handling of chuck strings, 
    addressing related instability and averting potential crashes
- (fixed) Stk WvOut for MAT (MATLAB) format; previously closing a
    MAT file in WvOut results in an assertation failure; this has been
    addressed.
- (fixed) WvOut and WaveLoop playback for non-16bit data formats;
    previously was normalizing to 16-bit signed int, regardless of
    data format
- (updated and fixed) memory system upgrade (part 1); scope-sensitive
    cleanup for each return statement; clarified reference counting
    semantics; function argument release for builtin functions; improved
    post-function call object cleanup; auto-reference-increment on
    returned objects from all builtin/imported functions;
- (updated) built-in abstract classes FM, StkInstrmnt, BLT, and
    FilterBasic, when used directly, issues a WARNING level log
    message in their respective synthesis tick functions (set log
    level in chuck or miniAudicle to WARNING or higher to enable
    printing), and allows program to procede silently. (Example that
    previously crashed: 'FM fm => dac; 1::second => now;')
- (developer) Chugin API clients in C++ now able to create
    strings and access member variables (thanks Nick Shaheed!)
- (developer) Chugin API query now able to add examples using
    QUERY->add_ex(...)


01.4.2.0 (January 2023)
---
(NOTE) chuck-1.4.2.0 marks a beginning (in BETA) of chAI => ChucK for AI 
-- a set of functionalities for interactive machine learning and artful, 
humanistic design of music and artificial intelligence; it coincides with 
the new "Music and AI" course at Stanford University, designed and taught 
by Ge Wang with Ph.D. candidate Yikai Li.

---
  - (added) MFCC unit analyzer (thanks Yikai Li)
        |- A unit analyzer that computes Mel-frequency Cepstral Coefficients
           (MFCCs), and outputs a vector of coefficients.
        |- (inheritance) MFCC -> UAna -> UGen -> Object
  - (added) examples: analysis/features/mfcc.ck
  - (added) all associative arrays now have a new method [thanks nshaheed]
        void getKeys( string[] keys );
        Return all keys found in associative array in keys
  - (added) Machine.realtime(): "return true if the shred is in realtime 
        mode, false if it's in silent mode (i.e. --silent is enabled)"
        -- thanks nshaheed --
  - (added) Machine.silent(): "return false if the shred is in realtime 
        mode, true if it's in silent mode (i.e. --silent is enabled)"
        -- thanks nshaheed --
  - (fixed) .help() now more accurately prints ("unit analyzer")
    for UAna types
  - (fixed) multi-variable array declaration; the following should
    now work:
        int x[1], y[2];
        int x, y[3];
  - (fixed) resolved an issue with multi-dimensional arrays pre-maturely
    releasing internal type data structure -- e.g., causing an assertion 
    failure in the second function call
        fun void test()
        {
            [ [1,2,3], [1,2,3] ] @=> int arr[][];
        }
        test();
        test();
  - (fixed) internal array storage now (more) correctly differentiate
    between int and float, on systems where the two are the same size
    (e.g., both 32-bit or both 64-bit)
  - (fixed) command line chuck: when opening default input audio device
        (e.g., Microphone), check for mono devices (the case on some MacOS
        systems) now happens earlier, before searching other 2-channel input
        audio devices; this preempts chuck using virtual audio input devices
        such as ZoomAudioDevice as the input device
  - (dev) added test examples in 01-Basic related to multi-var array
    declarations
  - (dev) extraneous white spaces removed throughout src/core
    ** thank you nshaheed for this soul-restoring measure **
  - (dev) all tabs replaced with 4 spaces, now consistent across project
    ** thank you nshaheed for this soul-restoring measure **
  - (dev) nshaheed: linux makefiles now correctly inserts Debug (-g)
    build flag when Debug build is enabled (default builds for Release)
-----------------------
(BETA) chAI-related additions: please note this is in Beta, meaning that 
APIs may change in the near future; many additions are in the works
-----------------------
  - (added) SVM object (thanks Yikai Li)
        |- a support vector machine (SVM) utility trains a model and 
           predicts output based on new input
        |- (inheritance) SVM -> Object
        |- methods:
           int predict( float[] x, float[] y );
               Predict the output 'y' given the input 'x'.
           int train( float[][] x, float[][] y );
               Train the SVM model with the given samples 'x' and 'y'.
  - (added) KNN object (thanks Yikai Li)
        |- A k-nearest neighbor (KNN) utility that predicts the output of 
           a given input based on the training data
        |- (inheritance) KNN -> Object
        |- methods:
           int predict( int k, float[] x, float[] prob );
               Predict the output probabilities (in 'prob') given new input
               'x' based on 'k' nearing neighbors.
           int train( float[][] x, int[] y );
               Train the KNN model with the given samples 'x' and 
           corresponding labels 'y'.
  - (added) HMM object (thanks Yikai Li)
        |- A hidden markov model (HMM) utility that generates a sequence 
           of observations based on the training data
        |- (inheritance) SVM -> Object
        |- methods:
           int load( float[] initiailDistribution,
                     float[][] transitionMatrix, 
                     float[][] emissionMatrix );
               Initialize the HMM model with the given initial state 
               distribution, transition matrix, and emission matrix.
           int train( int numStates, int numEmissions,
               int[] observations );
           Train the HMM model with the given observations.
           int generate( int length, int[] output );
               Generate a sequence of observations of the given length.
  - (added) basic usage examples in examples/ai/ folder
        |- also can use the built-in help() function
           KNN.help(); // this will print KNN type info and API
           SVM.help(); // this will print SVM type info and API
           HMM.help(); // this will print HMM type info and API
-----------------------
(BETA) end chAI additions
-----------------------
    

1.4.1.1 (May 2022)
---
  - (added) native support for Apple Silicon (e.g., M1) as intel/apple 
    universal binary; *significant* performance throughput observed
    running chuck natively on Apple Silicon
  - (modified) building from source, on MacOS command line:
        > make mac (compile for current architecture: arm64/x86_64)
        > make mac-ub (compile universal binary: arm64+x86_64)
        > lipo -archs ./chuck (checks architectures)
        > ./chuck --about (prints out compiled platform...
          ...and if compiled as universal binary):
          ---
          chuck version: 1.4.1.1 (numchucks)
          macOS : 64-bit [universal binary]
          ---
        > make osx (deprecated; use 'make mac' or 'make mac-ub')
  - (updated, pre-built executables, MacOS) both command line chuck and
    miniAudicle are now built as universal binaries to support both
    intel(x86_64) and Apple silicion/M1(arm64) architectures
  - (updated, pre-built executables, MacOS) all packaged chugins are
    now also built as universal binaries
  - (added) Math.equal( float x, float y )
    returns whether two floats are considered equivalent
  - (added) array.popOut( int index )
    removes an array element by index [thanks chamington and nshaheed]
  - (added) OscOut.send() error reporting now includes the intended
    recipient (hostname:port)
  - (added) examples/hid/gametra.ck
    boilerplate gametrak code
  - (moved) examples/osc/1-send-recv/
    moved s.ck and r.ck (sender and receiver) examples here
  - (added) examples/osc/2-multi-msg/
    examples for interleaving two OSC message types at different rates
  - (added) examples/osc/3-one2many/
    examples showing one sender to many receivers
  - (added) examples/osc/4-multicast/
    examples showing one sender using multicast to broadcast
  - (added) examples/stk/hevymetl-dance-now.ck
    example of power chords in sequence
  - (fixed) fixed Lisa-load.ck to correct load sound file [thanks nshaheed]
  - (fixed) CK_STDCERR now flushes on all output
  - (fixed) error message display for MidiFileIn (STK)
  - (fixed) array literal assignment now works as expected when
    common ancestor type is child type of the RHS type; [thanks nshaheed]
    --- for example ---
    [ new SinOsc ] @=> Osc arr[]; // previously this results in a
                                  // incompatible type error, although
                                  // Osc is a superclass SinOsc
    -------------------
  - (continuous integration) --  updated to use 'make mac'
  - (test) -- modified 01-Basic/86.ck; disabled 87.ck due to 
    Math.isnan() behaving differently on Apple Silicon;
    modified 03-Modules/std01.ck to handled floating point equivalence
    differently; also prompted adding Math.equal(); modified
    05-Global/86.ck to disable Math.isnan()
  - (updated, internal) integer types update for smoother Windows 64 bit
  - (noted) synchronization point for Chunity version x.x.x
  - (added) added to VERSIONS (this file) release dates since initial
    release in 2004


1.4.1.0 (June 2021)
---
(NOTE) chuck-1.4.1.0 is the first significant release resulting from a 
coordinated team effort to update and improve ChucK for teaching and 
research.  In April 2021, Perry and Ge led a ChucK "Global 
Repair-a-thon", which identified issues and put forth a new Development 
Roadmap. The ChucK dev team will follow this roadmap for updates, new 
features, and new ChucK mediums (e.g., Chunity, WebChucK, FaucK, 
ChucKTrip, and more). Many people were involved in this significant 
release, including Jack Atherton, Mike Mulshine, Matt Wright, Rebecca 
Fiebrink, Dan Trueman, Lloyd May, Mark Cerqueira, Mario Buoninfante, 
Perry Cook, Spencer Salazar, and Ge Wang.  Many thanks to everyone who 
contributed. Happy ChucKing!
---
  - (added) static Object.help();
    All ChucK objects (i.e., all non-primitive types) can now invoke 
    .help(), which will dynamically generate and print to console
    the description and inheritance hierarchy of the underlying type,
    as well as the available functions at runtime.  This can be called
    on any object instance or on any class (without an instance):
        // any object instance
        SinOsc foo;
        // print to console info about its underlying type
        foo.help();
        (OR)
        // call help() from any class (identical output as above)
        SinOsc.help();
    Intended to be a quick runtime reference / learning tool!
  - (added) examples/help.ck -- show .help() in action
  - (added) examples/deep/chant.ck (by Perry Cook, 2006) -- a chant singing
    synthesizer that makes use of ChucK's strongly-time and concurrent
    programming features.
  - (added) new Multi-channel LiSa UGens! (LiSa10 was already present)
        LiSa2 (stereo)
        LiSa4 (quad),
        LiSa6 (6-channel; laptop orchestra edition!)
        LiSa8 (8-channel),
        LiSa16 (16-channel)
  - (fixed) LiSa playback bug; voice panning now handles the mono case;
    previously was silencing voice playback
  - (added) new STK set/get access functions in FM:
        float op4Feedback( float value );
            Set operator 4 feedback.
        float op4Feedback();
            Get operator 4 feedback.
        float opADSR( int opNum, float a, float d, float s, float r );
            Set operator ADSR: attack, decay, sustain, release.
        float opAM( int opNum, float value );
            Set operator amplitude modulation.
        float opAM( int opNum );
            Get operator amplitude modulation.
        float opGain( int opNum, float value );
            Set operator gain.
        float opGain( int opNum );
            Get gperator gain.
        float opRatio( int opNum, float ratio );
            Set operator frequency ratio.
        float opRatio( int opNum );
            Get operator frequency ratio.
        float opWave( int opNum, int wave );
            Set operator waveform [1-8].
  - (added) new Synthesis Toolkit (STK) FM instruments from Perry!
        HnkyTonk: STK-style Honkey Tonk Piano FM synthesis instrument.
            (aka, Algorithm 1 of the Yamaha TX81Z DX11 FM synthesizer)
        FrencHrn: STK-style French Horn FM synthesis instrument.
            (aka, Algorithm 2 of the Yamaha TX81Z DX11 FM synthesizer)
        KrstlChr: STK-style "Crystal Choir" FM synthesis instrument.
            (aka, Algorithm 7 of the Yamaha TX81Z DX11 FM synthesizer)
    *** for each of these, try using the new .help() to examine its
    documentation and interface; e.g., HnkyTonk.help(); ***
  - (added) new Moog function:
        float filterStartFreq( float freq );
            Set filter starting frequency.
        float filterStartFreq();
            Get filter starting frequency.
  - (added) new STK examples:
        examples/stk/frenchrn-algo2.ck -- FM French Horn demo
        examples/stk/honkeytonk-algo1.ck -- fun with FM Honkey Tonk
        examples/stk/krstlchr-algo7.ck -- heavenly FM Kristal Choir
        examples/stk/hevymetl-acoustic-algo3.ck -- FM HevyMetl => Nylon Guitar
        examples/stk/hevymetl-trumpet-algo3.ck -- FM HevyMetl => Trumpet
        examples/stk/rhodey-song.ck -- a lovely little number
  - (updated) tweaks to a number of STK UGens, which may result in audio
    changes; the affected UGens are:
        BandedWG, BeeThree, FMVoices, HevyMetl, PercFlut, Rhodey,
        TubeBell, Wurley
  - (fixed) issue in PluckTwo in computing delay length; this affects
    the tuning of various plucked string models, including Mandolin.
  - (added) .frames() for SndBuf and SndBuf2; returns the number of sample
    frames in the loaded sound file. This is identical in behavior to
    .samples() -- but for stereo+, .frames() is semanitically more 
    accurate than .samples().
  - (added) "global" declarations for int, float, string, Object, UGen, Event;
    this can be used in-language across ChucK files (each file must first 
    "declare" the global value before using it). This also support usage from
    external hosts such as Chunity. (thanks to Jack Atherton for this work!)
  - (added) constant power panning (as controlled by the .pan parameter)
    for all UGen_Stereo--including Pan2, stereo dac, stereo adc; this is
    controllable using the new .panType parameter.  By default, constant
    power panning is NOT enabled for dac and adc, whose panning behavior 
    is unchanged (panType==0) and favors a kind of unity-gain-preserving
    but perceptually suspect panning scheme. By contrast, Pan2 will default
    to use constant power panning (panType==1).  This change will alter the
    effect of any existing code that uses Pan2.  Specifically, it will
    introduce a ~3 dB reduction in the output Pan2 (it is possible to
    restore the previous behavior by explicitly setting .panType to 0). 
    This ~3 dB reduction corresponds to the equal-powered amplitude value
    when pan is at center (pan=0). Mathematically, the reduction amount 
    can be calculated using Std.lintodb(Math.cos(pi/4))
    [To hear this new behavior, check out examples/stereo/stereo_noise.ck]
  - (BEHAVIOR CHANGED) clearly separated array.size() and array.capacity();
    for historical/compatibility reasons, array.cap() is the same as
    array.size() and generally should be avoided in favor of either .size()
    or .capacity()
  - (BEHAVIOR CHANGED): internally, all ChucK static functions are now
    passed an extra parameter (Chuck_Type * TYPE) as a pointer to the
    base type/class. This will affect Chugins, which should be updated/
    rebuilt with the latest headers.
  - (BEHAVIOR CHANGED): when connecting two multi-channel UGen's (both
    are at least stereo), say LHS => RHS, if LHS channels < RHS channels,
    the channels will be connected one-by-one up to the LHS channel count;
    previously, the LHS channels will be automatically repeated to connect
    to the RHS channels that have no corresponding LHS channels.  This
    behavior can still be achieved by manually connecting the individual
    channels of LHS and and RHS through LHS.chan(n) and RHS.chan(n).
  - (fixed) resolved a bug with SndBuf not playing when .rate < 0 and while
    .pos beyond the end
  - (fixed) resolved a bug with SndBuf where it could output DC when .rate < 0
    after it reaches the beginning of the file (e.g., if the first sample is
    non-zero)
  - (fixed) resolved a bug in ADSR when sustain is set to 0 and audio stops,
    .releaseTime return NaN and basically the world ends (thanks to
    mariobuoninfante for help in addressing this)
  - (fixed) reset Gen10 table to allow add/remove partials; thanks to 
    mariobuoninfant
  - (fixed) updated MidiOut and removed check in order to allow messages
    of size less than or greater than 3 bytes; thanks to mariobuoninfante
    for this issue report on Ubuntu Studio 64-bit; this fix addresses
    the sending of MIDI clock, stop, continue, and SysEx -- also thank 
    you mariobuoninfante for the fix.
  - (fixed) ChucK shell can now be exited either by the "exit" command
    or through ctrl-c.  Previously. ctrl-c sometimes failed to end the
    the program due to logic in the global cleanup function; this has
    been addressed.
  - (fixed) addressed an issue where Chugins were being loaded twice.
  - (fixed) the --chugin-load:off option is now correclty taken into
    account and will appropriately result in no Chugins being loaded.
  - (deprecated) Chubgraph => (new) Chugraph;
    Chubgraph will continue to function, with a deprecation warning.
  - (documentation) updated embedded documentation text for all statically
    linked UGens and libraries.
  - (documentation) brought examples in alignment between distribution
    and the online examples collection; many examples updated for clarity
    and utility
        http://chuck.stanford.edu/doc/examples
        http://chuck.cs.princeton.edu/doc/examples
  - (internal/refactor) the "Mega Merge 2021" integrates a long-standing
    branch since REFACTOR-2017 that includes support for globals and was
    the basis for Chunity.  Future Chunity releases will align with mainline
    ChucK language features. (thanks to Jack Atherton for several years of
    laying the groundwork and for ChucK in Chunity!)
  - (internal/developement) added m_started flag to the ChucK class to avoid
    a strange (but mostly harmless) condition when the virtual machine is
    shutting down and ChucK::run() attempt to call ChucK::start()
  - (internal/development) Thanks to Mark Cerqueira -- migrated from old
    Travis CI (continuous integration testing) to GHA (GitHub Actions).


1.4.0.1 (May 2020)
---
  - (fixed) when opening audio input devices where the default
    device has insufficient chanels (e.g., MacOS input is mono
    by default), logic has been added to also match sample rates
    when searching for alternate audio input devices;  additional
    logic added in the specific case of mono input devices to
    simulate stereo, to fulfill the standard request for stereo
    input.
  - (fixed) added check to prevent crash in rare situations involving
    self-join when deleting XThread in background. (git PR #103)
  - (fixed) by stuntgoat@github -- right-recursion in chuck parser
    can exhaust memory in larger chuck files; this has been updated
    to use left recursion.  (git PR #32, (finally) merged by hand by 
    Spencer and Ge)  Also thanks to Tom Lieber for the initial analysis
    and solution:
    https://lists.cs.princeton.edu/pipermail/chuck-users/2009-April/004029.html
  - (added) by Nathan Tindall -- Q and freq bounding for filters (LPF,
    HPF, BPF, BRF) to avoid LOUD FILTER EXPLOSIONS; now negative values
    will throw an exception on the offending shred.
  - (restored, macOS) MAUI Chugin now (re)supported, post 1.4.0.0
  - (added; developer) ChucK.h API to set a main thread hook (e.g., for 
    graphical functionalitie from Chugins)
  - (updated, developer) Chugin API now support main thread callback
    for graphical-/GUI purposes
  - (developer) refactored code to move I/O-related code out of
    chuck_lang and into chuck_io.


1.4.0.0 (February 2018)
---
  ********************************************************
  * NOTE: 1.4.0.0 is a simultaneous release with 1.3.6.0;*
  * the two are identical except 1.3.6.0 also supports   *
  * earlier version of OS X before 10.9 (back to 10.5).  *
  ********************************************************
  * MAJOR SOURCE REFACTOR!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
  * (Thanks Jack Atherton for months of groundwork!)     *
  ********************************************************
  - (added) support for 64-bit on windows
  - (added) Chuck_External API for including and running ChucK from 
    elsewhere in C++
            - specify the sample rate
            - optionally specify the directory that me.dir() should 
              evaluate to; this dir will also be scanned for chugins
            - optionally use custom callbacks for out and err messages
              from ChucK
  - (added) external keyword - for communicating variable values to and from
            C++ code using Chuck_External API
  - (developer) ChucK "core" as library, independent of external
    system audio I/O; now much easier to embed ChucK as a
    component in other hosts (e.g., command line, plugins, Unity, etc.)
  - (developer) ChucK "host" (command line app)
  - (developer) SOURCE: code support for multiple ChucK/VM instances
  - (developer) SOURCE: one file to include them all (chuck.h)
  - (developer) c_str() method for Chuck_Strings, so that chugins with a different
            definition of std::string can still construct their own string
  - (developer) API for chugin API calls
              - now API variable must be passed
              - SHRED variable must also occasionally be passed
  - (internal) refactored Chuck_String representation to be immutable
  - (internal) refactored to eliminate global VM, compiler, and env variables
              - compiler stores a reference to env
              - compiler stores a reference to vm
              - vm stores a reference to env
              - env stores its own top-level types; no more global type variables
              - DL_Query stores a reference to compiler
  - (internal) refactored all print statements to use new macros


1.3.6.0 (February 2018)
---
  - (see 1.4.0.0)


1.3.5.3 (unreleased; rolled into 1.4.0.0)
---
  - (added) support for primitive type 'vec3' for 3D vector
            - access .x .y .z OR .r .g .b OR .value .goal .slew
  - (added) support for primitive type 'vec4' for 4D vector
            - access .x .y .z .w OR .r .g .b .a
  - (added) VM exceptions (e.g., ArrayOutOfBounds) now print line number
            where possible (thanks Jack Atherton!)
  - (added) Math.gauss( x, mu, sigma )
  - (added) .clear() for Delay, DelayA, DelayL
  - (fixed) - == and != for polar and complex types
  - (fixed) repeat statement now worked correctly for shreds
  - (fixed) crash with --adaptive:N and ugens that used tickf e.g. WvOut2
  - (fixed) SndBuf occasional crash at end of file
  - (fixed) (windows) install issue where chugins and/or example files were missing
  - (removed) --blocking functionality; callback only for real-time audio
  - (internal) refactored VM to be more friendly for integration


1.3.5.2 (October 2015)
---
  - (added) default root path changed from /usr to /usr/local
            (fixes issues in Mac OS X 10.11 "El Capitan")
  - (added) new ChuGins
            - FoldbackSaturator
              by Ness Morris
              Foldback Saturator for nasty distortion.
            - WPDiodeLadder
              by Owen Vallis
              Diode ladder filter based on Will Pirkle's technical notes.
            - WPKorg35
              by Owen Vallis
              Korg 35 low-pass filter based on Will Pirkle's technical notes.
  - (fixed)(Win) missing DLL issue
  - (fixed) me.dir() issues with Machine.add()-ed shreds
  - (fixed) crash fixes for <<< >>> with null objects
  - (fixed) stop ignoring midi clock in midi messages
  - (fixed) crash fix for array => ugen
  - (fixed) fix OscOut send failure for programs that also use OscIn


1.3.5.1 (April 2015)
---
  - (added) new ChuGins
            - PowerADSR
              by Eric Heep
              Power function ADSR envelope.
            - WinFuncEnv
              by Eric Heep
              Envelope built on window functions.
  - (added) more aggressive optimizations for ARM platforms
  - (fixed) SndBuf fixes
  - (fixed) SerialIO fixes:
            - newline handling
            - full-duplex IO
            - general lag issues


1.3.5.0 (December 2014)
---
  - (added) new functions in Std
            - int Std.clamp(int v, int min, int max)
              Return v constrained to [min, max]
            - float Std.clampf(float v, float min, float max)
              Return v constrained to [min, max]
            - float Std.scalef(float v, float srcmin, float srcmax, 
                               float dstmin, float dstmax)
              Scale v to range [dstmin, dstmax]. v is assumed to have the range
              [srcmin, srcmax]. 
            - float Std.dbtolin(float x)
              Convert x dB to linear value
            - float Std.lintodb(float x)
              Convert linear value x to dB
  - (added) MidiIn.open(string)/MidiOut.open(string) will open devices matched 
            by partial match if no full device-name match is found. 
  - (added) examples/osc/osc_dump.ck example 
  - (added) new static variables in ADSR
            - .ATTACK, .DECAY, .SUSTAIN, .RELEASE, .DONE
              values corresponding to current state, returned by ADSR.state()
  - (added) full book/digital-artists examples
  - (fixed) real-time audio hiccuping/underrun when loading files in SndBuf
            - SndBuf .chunks now uses .chunks as buffer size for dynamic loading
            - files are loaded .chunks samples at a time
            - memory for the file is divided into buffers of .chunks samples
            - chunk size defaults to 32768 samples
  - (fixed) DLL issue on Win32 command line build
  - (fixed) non-void functions implicitly return 0/null if no return statement
  - (fixed) --probe crashes and other crashes related to error logging
  - (fixed) include trailing slash in me.dir() and friends
  - (fixed) fix me.path()/me.dir() for input paths with implicit .ck extension
  - (fixed) better error messages for OscIn/OscOut
  - (fixed) rare threading bug for OTF commands


1.3.4.0 (April 2014)
---
  - (added) chuck operator connects between arrays of ugens, multi-channel 
            ugens, and mono unit ugens
            ex. 
                SinOsc s => Pan2 pan => Gain master[2] => dac;
            persists stereo signal through master to dac. 
            See examples/stereo/array.ck for example usage. 
  - (added) new OSC support classes
            - OscOut
              Sends OSC messages
                - .dest(string host, int port)
                  set destination hostname or IP address and port
                - .start(string addr)
                  set target OSC address to addr
                - .add(int i)
                - .add(float f)
                - .add(string s)
                  add argument to the message
                - .send()
                  send message
            - OscIn extends Event
              Receives OSC messages
                - int .port
                  port number to listen to
                - .addAddress(string addr)
                  listen for OSC addresses matching addr
                - .removeAddress(string addr)
                  stop listening for OSC addresses matching addr
                - .listenAll()
                  listen for all incoming OSC messages on port
                - int .recv(OscMsg msg)
                  retrieve pending OSC messages into msg. Returns 1 if a 
                  message was available, 0 otherwise
            - OscMsg
              Encapsulates a received OSC message
                - string .address
                  the OSC address this message was sent to
                - string .typetag
                  the OSC typetag of this message
                - int .getInt(int i)
                - float .getFloat(int i)
                - string .getString(int i)
                  retrieve the argument at position i of the given type
            See examples/osc/ for examples on usage. 
            OscRecv and OscSend are still supported for backwards compatibility,
            but new code should use OscIn and OscOut. 
  - (added) new SerialIO functions
            - .writeByte(int b)
              write byte b to the serial stream
            - .writeBytes(int b[])
              write array of bytes b to the serial stream
  - (added) new chugins (from Joel Matthys)
            - PitchTrack
              Monophonic autocorrelation pitch tracker, based on [helmholtz~] by
              Katja, http://www.katjaas.nl/helmholtz/helmholtz.html
            - GVerb
              Good quality stereo reverb with adjustable parameters
            - Mesh2D
              STK instrument that simulates a rectilinear, 2-dimensional digital
              waveguide mesh structure. Basically sounds like striking a metal 
              plate.
            - Spectacle
              FFT-based spectral delay and EQ
            - Elliptic
              Elliptic filter, capable of very steep slopes or interesting 
              harmonic ripples
  - (fixed) ChucK Shell fixes


1.3.3.0 (November 2013)
---
  - (added) PulseAudio support (via RtAudio)  
  - (fixed) relative path resolution for me.path() and me.dir()
  - (fixed) C:/ style pathnames do not trigger spurious argument processing
  - (fixed) MidiFileIn on Windows/Linux


1.3.2.0 (September 2013)
---
  - (added) --clear.vm flag
            instructs remote VM to remove all shreds and clear public user types
  - (added) Std.ftoi(float f)
            Function for converting float to int
  - (added) ASCII char literals - 'c' converted to int with ASCII value
  - (added) book/digital-artists example programs for forthcoming book:
            "Programming for Musicians and Digital Artists" (Manning 
            Publications)
            (very special thanks to Mark Morris and Bruce Lott for sample
            production)
  - (added) new functions
            - me.path()
              equivalent to me.sourcePath()
            - me.dir()
              equivalent to me.sourceDir()
            - me.dir(int N)
              return Nth-level parent of source directory
            - Shred.fromId(int id)
              return Shred object corresponding to specified id
  - (added) new functions for string objects
            - .charAt(int index)
              return character of string at index
            - .setCharAt(int index, int ch)
              set character of string at index to ch
            - .substring(int pos)
              return new string with characters from pos to end of string
            - .substring(int pos, int len)
              return new string with characters from pos of length len
            - .insert(int pos, string str)
              insert str at pos
            - .erase(int pos, int len)
              remove len characters from string, beginning at pos
            - .replace(int pos, string str)
              replace characters of string at pos with str
            - .replace(int pos, int len, string str)
              replace len characters of string with str, starting at pos
            - .find(int ch)
              search for character ch in string, return index of first instance
            - .find(int ch, int pos)
              search for character ch in string, return index of first instance
              at or after index pos
            - .find(string str)
              search for string str in string, return index of first instance
            - .find(string str, int pos)
              search for string str in string, return index of first instance at
              or after index pos
            - .rfind(int ch)
              search for character ch in string, return index of last instance
            - .rfind(int ch, int pos)
              search for character ch in string, return index of last instance
              at or before index pos
            - .rfind(string str)
              search for string str in string, return index of last instance
            - .rfind(string str, int pos)
              search for string str in string, return index of last instance at
              or before index pos
  - (added) MidiFileIn class
            Class for parsing + handling MIDI input from a file.
            See examples/midi/playmidi.ck for example usage. 
            - .open(string filename)
              Open file at specified path
            - .read(MidiMsg inMsg)
              Get next message in first track
            - .read(MidiMsg inMsg, int trackNo)
              Get next message in trackNo
  - (added) SerialIO class (extends IO)
            Class for communicating with serial devices, e.g Arduino.
            See examples/serial/ for example usage. 
            - .list() (static)
              return array of strings corresponding
              to available serial IO devices
            - .open(int i, int baud, int mode)
              open device with index i. baud can be a constant specifying
              which standard serial baud rate is used (e.g. 
              SerialIO.B9600). mode can be SerialIO.ASCII or 
              SerialIO.BINARY to specify ASCII or binary interpretation
              of serial data. 
            - .onLine()
            - .onByte()
            - .onBytes(int num)
            - .onInts(int num)
            - .onFloats(int num)
              chuck to now to wait for that type of data to arrive (in the
              specified quantity). E.g. serial.onLine() => now; will wait 
              for 1 newline-terminated string to arrive from the serial
              device. 
            - .getLine()
              .getByte()
              retrieve data requested as above as string/byte
            - .getBytes()
              .getInts()
              .getFloats()
              retrieve data requested using the onLine()/etc. above. as array
              of data type
            - .baudRate()
              .baudRate(int baud)
              get/set baud rate
            - SerialIO.B2400
              SerialIO.B4800
              SerialIO.B9600
              SerialIO.B19200
              SerialIO.B38400
              SerialIO.B7200
              SerialIO.B14400
              SerialIO.B28800
              SerialIO.B57600
              SerialIO.B115200
              SerialIO.B230400
              available baud rates
  - (added) Regex class
            Class for regular expression matching and replacing in strings. 
            Regex style is POSIX-extended. 
            - RegEx.match(string pattern, string str)
              Return true if match for pattern is found in str, false otherwise
            - RegEx.match(string pattern, string str, string matches[])
              Same as above, but return the match and sub-patterns in matches
              matches[0] is the entire matched pattern, matches[1] is the first 
              sub-pattern (if any), and so on. 
            - RegEx.replace(string pat, string repl, string str)
              Replace the first instance of pat in str with repl, returning the
              result. 
            - RegEx.replaceAll(string pat, string repl, string str)
              Replace all instances of pat in str with repl, returning the
              result. 
  - (fixed) --adc:<N> now works as expected
  - (fixed) FileIO => string bug
  - (fixed) LiSa.sync/LiSa.track now works when set to 
            1 (playhead follows input, normalized/rectified to [0,1])
            2 (playhead follows input, non-normalized/rectified)
            affects examples/special/LiSa-track*.ck
  - (fixed) LiSa interpolation bug
  - (fixed) .clear() function of arrays properly removes all items of the array
  - (fixed) != properly handles comparison between a string and literal null
  - (fixed) multichannel refcounting bug
  - (fixed) WvOut performs IO writes on separate thread, significantly 
            minimizing audio underruns
  - (fixed) crash in Chorus destructor
  - (fixed) crash in Mandolin destructor
  - (fixed) ADSR correctly initialized in "DONE" state


1.3.1.3 (September 2012)
---
  - (fixed) number in --dac:<N> flag is no longer off by one (this bug
            was introduced in 1.3.1.2)


1.3.1.2 (September 2012)
---
  - (added) chuck now automatically detects and uses next highest
            or closest (in that order) system sample rate in   
            the case where the default is not available; if a sample
            rate requested via --srate: is not available, an error
            will be encountered with a message.
  - (fixed) base parent object is correctly accounted for by 
            new shred when sporking member functions
            (thanks to Michael Heuer for reporting and 
             narrowing this down)
  - (fixed) popping local variables from the operand stack in cases
            where the datatype size is larger than int-size; this
            is a bug introduced with 64-bit in 1.3.1.0, and exhibited
            on 32-bit systems only.  (thanks to Simon Steptoe 
            reporting and narrowing this down)
  - (fixed) opening real-time audio with 0 input channels should
            now work, once again.


1.3.1.1 (September 2012)
---
  - (fixed) critical bug since 1.3 where member function calls in
            loop conditionals caused crashes when the loop body
            contained local Object's to be released;  this directly
            affects using OSC, MIDI, HID, which commonly employ 
            syntax like: 'while( e.nextMesg() ) { ... }';
            -- this is most likely the cause of the OSC-related issues
            we've been seeing (thanks to Graham Coleman for tracking 
            down and narrowingthe issue!)
  - (fixed) strengthened synchronization in OSC between internal
            listener thread and chuck VM code
  - (fixed) memory bug in OscRecv deallocation
  - (fixed) Machine.add( ... ) on windows now supports both '\\'
            and '/' in aboslute paths (previously only '\\').
            (thanks to Graham Coleman for finding this!)


1.3.1.0 (September 2012)
---
  - (added) 64-bit support for all platforms (OS X, Linux, Windows)
            many thanks to Paul Brossier, Stephen Sinclair, 
            Robin Haberkorn, Michael Wilson, Kassen, and 
            Fernando Lopez-Lezcano, and chuck-users!
  - (added) Math.random(), random2(), randomf(), random2f(), srandom(),
            and Math.RANDOM_MAX;  NOTE: randomf() returns range 0.0 to 1.0
            these use the much better random() stdlib functions
            the existing Std.rand*() and Std.srand() is still
            be available for compatibility (these to be deprecated
            in the future; please start using Math.random*())
            * (NOTE: on windows, Math.random() still uses the same
              generator as Std.rand() -- we hope to improve this in
              a future version!)
            * (NOTE: also see removed below)
  - (added) chuck --version | chuck --about now print architecture
            (32-bit or 64-bit)
  - (added) Machine.intsize() will return int width in bits (e.g., 32 or 64)
  - (added) examples/array/array_mmixed.ck to verify mixed-index
            fix (see below), based on Robin Haberkorn's test code
  - (fixed) multi-dimensional arrays now correctly support mix-typed
            indices (e.g., strings & ints) (thanks Robin Haberkorn)
  - (fixed) constants in Math library now cleaner, they include:
            * Math.PI
            * Math.TWO_PI
            * Math.e or Math.E
            * Math.i or Math.I or Math.j or Math.J // as 'complex' type
            * Math.INFINITY
            * Math.RANDOM_MAX
            * Math.INT_MAX // currently, differs on 32-bit and 64-bit systems
            * Math.FLOAT_MAX
            * Math.FLOAT_MIN_MAG // minimum positive float value
  - (fixed) Chubgraph.gain(), .last(), and .op()
  - (fixed) error message printing system for variable arguments
  - (fixed) StifKarp.sustain now works properly
  - (fixed) all examples now use Math.random*() instead of Std.rand*()
  - (removed) Math.rand*() removed --> please use Math.random*();
            (see 'added' above; Std.rand*() still there, but to be 
            deprecated; please use Math.random*() moving forward)


1.3.0.2 (August 2012)
---
  - (fixed) string literal reference counting
  - (fixed) chuck to function call reference counting


1.3.0.1 (August 2012)
---
  - (fixed) WvOut no longer only record silence
  - (fixed) WvOut.closeFile() does not cause the VM to hang


1.3.0.0 (August 2012)
---
  - (added) Chugins: dynamically loaded compiled classes/ugens
            see http://chuck.stanford.edu/extend/ for examples. 
  - (added) new command line options
            --chugin-load:{auto|off}     disable/enable chugin loading
            -gFILE/--chugin:FILE         load chugin at FILE
            -GPATH/--chugin-path:PATH    load all chugins in directory PATH
            --dac:NAME                   use dac with name matching NAME
            --adc:NAME                   use adc with name matching NAME
  - (added) Chubgraphs: create ugens by compositing existing UGens
            see examples/extend/chubgraph.ck
  - (added) ChuGens: create ugen by implementing audio-rate processing in ChucK
            see examples/extend/chugen.ck
  - (added) new ugens:
            - WvOut2: stereo uncompressed audio file output
            - SndBuf2: stereo uncompressed audio file input
  - (added) new functions:
            - me.sourcePath()
                returns file path of source file corresponding to this shred
            - me.sourceDir()
                returns directory of source file corresponding to this shred
            - MidiIn.open(string name)
                open MIDI input matching name
            - MidiOut.open(string name)
                open MIDI output matching name
            - Hid.open(string name)
                open HID matching name
  - (added) experimental OS X multitouch HID
  - (fixed) real-time audio on Mac OS X 10.7 (Lion), 10.8 (Mountain Lion)
  - (fixed) IO.newline() now flushes "chout"
  - (fixed) "chout" and "cherr" now invoke member functions correctly
  - (fixed) no for statement conditional handled correctly
  - (fixed) STK WvOut correctly handles case when file open fails
  - (fixed) << operator for arrays now correctly references counts
  - (fixed) crashing bug when receiving external events at a high-rate
            ("the OSC bug")
  - (fixed) scope closing correctly dereferences local objects
  - (fixed) crash when exiting shreds with connected ugens
  - (fixed) deallocation of "empty" Shred object no longer crashes
  - (fixed) crash when HID events are sent to an exited shred
  - (fixed) destructors for built-in objects are executed


1.2.1.3 (October 2009)
---
  - (added) initial/experimental support for file I/O (finally)
            (thanks to Andrew Schran, Martin Robinson)
  - (added) new class: IO, FileIO
            see examples/io/:
                read-int.ck
                read-str.ck
                readline.ck - using readline
                write.ck - write using <=
                write2.ck - write using .write()
  - (added) IO input via =>
  - (added) IO output via <= (the "back-chuck")
            example: fio <= x <= " " <= y <= "\n";
  - (added) new syntax for checking if/while/for/until with IO objects
            e.g., while( fio => i ) { ... }
  - (added) StdOut/StdErr objects:
            "chout" (pronounced "shout")
            "cherr" (pronounced "Cher")
  - (added) Hid.open() now can accept a device name parameter
  - (added) analysis/tracking examples are now back
            (thanks to Kassen for looking into this)
  - (fixed) calling overloaded functions with most specific match
            e.g., Specific extends General:
            fun void foo( General obj ) { }
            fun void foo( Specific obj ) { }
            foo( obj $ Specific ); // should call foo( Specific )
            (thanks to Robert Poor for reporting, to Kassen, David Rush,
            Michael Heuer, and Andrew C. Smith for follow-up)
  - (fixed) STK instruments control changes reports range issues as
            "control value exceeds nominal range"; previously printed
            hard-coded values that were potentially misleading
            (thanks to Kassen for reporting)
  - (fixed) all oscillators now produce audio for negative frequencies
            (thanks to Luke Dahl)
  - (fixed) incorrect UGen disconnect (thanks Kassen for reporting)
  - (fixed) type checker now validates if/while/for/until types
  - (fixed) linux compilation (for gcc 4.x)
  - (fixed) complilation on OS X Snow Leopard


1.2.1.2 (July 2008)
---
  - (added) dynamic, resizable arrays
                .size( int ) resizes array; .size() returns current size()
                << operator appends new elements into array
                .popBack() pops the last element of the array, reducing size by 1
                .clear() zero's out elements of the array
            (see examples/array/
                array_dyanmic.ck
                array_resize.ck)
  - (added) new UAna: FeatureCollector
            turns UAna input into a single feature vector, upon .upchuck()
            new UAna: Flip
            turns audio samples into frames in the UAna domain
            new UAna: pilF
            turns UAna frames into audio samples, via overlap add
            new UAna: AutoCorr
            computes the autocorrelation of UAna input
            new UAna: XCorr
            computes the cross correlation of the first two UAna input
  - (added) UGen.isConnectedTo( Ugen )  // is connected to another ugen?
  - (added) UAna.isUpConnectedTo( UAna )  // is connected to another uana via =^?
  - (added) int Shred.done()  // is the shred done?
            int Shred.running()  // is the shred running?
  - (added) int Math.ensurePow2( int )
  - (added) Math.INFINITY, Math.FLOAT_MAX, Math.FLOAT_MIN_MAG, Math.INT_MAX
  - (added) TriOsc.width(), PulseOsc.width(), SawOsc.width(), SqrOsc.width()
  - (added) Std.system(string) is now disabled by default, to enable: specify
            the --caution-to-the-wind command line flag, for example:
                %> chuck --caution-to-the-wind --loop
  - (removed) SqrOsc.width( float ), width is always .5
  - (fixed) it's now (again) possible to multiply connect
            two UGen's
  - (fixed) OS X only: sudden-motion-sensor HID no longer 
            introduces audio dropouts below peak CPU usage
            due to added centralized polling;
            added static Hid.globalPollRate( dur ) to control
            the central SMS polling's rate
  - (fixed) Windows only: implementation of array via STL vector::reserve()
            has been replaced with a more compatible approach (see chuck_oo.cpp)
  - (fixed) dac amplitude no longer halved!
            NOTE: this increases the gain from before by
            a factor of 2, or roughly 6 dB!!  BEWARE!!
  - (fixed) corrected order of shred/ugen dealloc in VM destructor,
            preventing a potential crash during shutdown
  - (fixed) UAna can now upchuck() at now==0
  - (fixed) STK Chorus UGen now has reasonable defaults
            .max( dur, float ) for initializing to delay/depth limits
            .baseDelay( dur ) sets current base delay
  - (fixed) dur +=> now no longer crashes
  - (fixed) ADSR now returns attackTime, decayTime, and releaseTime that corresponds
            to the duration-based setting functions (internally multiplied by SR)
            (thanks Eduard)
  - (fixed) STK Mandolin no longer plays without explicit noteOn
  - (fixed) unsporked Shred instances now given id == 0 (thanks Kassen)
  - (fixed) typos in ugen_xxx.cpp and chuck-specific rtaudio.cpp (/moudi)


1.2.1.1 (October 2007)
---
  - (fixed) ctrl-c no longer causes crash on shutdown
            (was due to memory deallocation bug)
  - (fixed) incorrect code generation for multiple expressions in 3rd clause 
            of for loops (thanks to Eduard for tracking!)
  - (fixed) Envelope now is able to ramp down (contributed by Kassen, Dr. Spankenstein, 
            kijjaz, and others on electro-music!)
            

1.2.1.0 (codename: spectral, August 2007)
---
  - (added) Unit Analyzers (UAna: prounced U-Wanna, plural UAnae)
              (primary creators: Rebecca and Ge)
            provides support for spectral processing, 
              information retrieval, generalized + precise audio analysis

  - (added) new datatypes:
            ---------
            complex: (real,imaginary)
                 example: #(3,4) is complex literal (3,4)
                 example: #(3,4) => complex value;
                          access components via value.re and value.im
                 used by UAnae

            polar: (modulus, phase)
                 example: %(.5, pi/4) is magnitude .5 and phase pi/4
                 example: %(.5, pi/4) => polar bear;
                          access components via bear.mag and bear.phase
                 used by UAnae
            ----------
            example: can cast between complex and polar via standard $ casting

  - (added) new UAna's:
            ----------
            (authors: Rebecca and Ge)
            FFT: Fast Fourier Transform
                 input: from UGen (manually input float vector)
                 output: complex spectrum (.cval()/.cvals())
                         magnitude spectrum (.cval()/.fvals())
                 (see examples/analysis/)
            IFFT: Inverse FFT
                 input: UAna/Blob complex vector (spectrum)
                 output: to UGen (as samples)
                 (see examples/analysis/)
            Centroid: Centroid feature extractor
                 input: UAna/Blob float vector (mag spectrum)
                 output: single centroid value per frame
                 (see examples/analysis/features/)
            Flux: Flux feature extractor
                 input: UAna/Blob float vector (mag spectrum)
                 output: single flux value between current and previous frame
                 (see examples/analysis/features/)
            RMS: RMS feature extractor
                 input: UAna/Blob float vector (mag spectrum)
                 output: single RMS value of frame
                 (see examples/analysis/features/)
            RollOff: RollOff feature extractor
                 input: UAna/Blob float vector (mag spectrum)
                        percentage threshold
                 output: single RollOff value of frame
                 (see examples/analysis/features/)
            ----------

  - (added) capability to externally abort "infinite loop" shreds
            (this deals with hanging shreds due to potentially
            infinite loops that don't advance time)
  - (added) OTF command: chuck --abort.shred sends network OTF
            to server to remove current shred if there is one
  - (added) default .toString() method to all Object's
  - (added) adding an Object to string will first cast object to string;
            then add the two
  - (added) LiSa.duration() get method, and .voiceGain() set/get
            (Dan Trueman)
  - (added) alternate line comment: <-- same as //
            example:
                 SinOsc s => dac;  <-- here is a comment
  - (fixed) NullPointerException when instantiating array of objects
            containing arrays of objects
                 (thanks to chuck-users!!)
  - (fixed) Machine.remove() on parent shred id no longer crashes
  - (fixed) Machine.remove() on 'me' now works correctly
  - (fixed) rounding when writing files via WvOut
                 (thanks to Chris Chafe for discovering and reporting this)
  - (changed) default frequencies (220/440) added for various STK instruments


---
(there is no version 1.2.0.9!)
---


1.2.0.8 (March 2007)
---
  - (added) command line argument support
            e.g. %> chuck foo.ck:1:hello bar:2.5:"with space"
                 also works with OTF commands
            e.g. %> chuck + foo:1:yo
                 also works with Machine.add( ... )
            e.g. // code
                 Machine.add( "foo:1:2:yo" );
            (see examples/basic/args.ck for accessing from code)
  - (added) OS X: watchdog enabled
            win32: watchdog implemented and enabled
            (combats chuck infinite empty loop implosion)
  - (added) OTF server/listener now ON by default...
            to enable, specify --loop or --server
            to disable, specify --standalone
  - (added) new UGens:
            --------
            Dynamics: dynamics processor (compressor, expander, etc.)
                  (author Matt Hoffman and Graham Coleman)
                  (see examples/special/)

            GenX: classic + new lookup table functions base class
                  (author Dan Trueman, ported from RTCMix)
                  (see examples/special/)

                  float .lookup( float ) : lookup table value
                  float[] .coeffs( float[] ) : load the table
            Gen5 (extends GenX)
            Gen7 (extends GenX)
            Gen9 (extends GenX)
            Gen10 (extends GenX)
            Gen17 (extends GenX)
            CurveTable (extends GenX)
            WarpTable (extends GenX)

            LiSa: (Li)ve (Sa)mpling!
                  (author Dan Trueman, partly based on Dan's munger~)

            --------
  - (added) (prototype) string catenation
            (for now will leak memory! use wisely!!!)
            e.g. // expression
                 "a" + "b"
                 "a" + 45
                 "a" + 5.1
                 "postfix" +=> str;
  - (added) string escape sequences
            \0 \n \t \a \" \b \f \r \v \\
            \nnn (3 digit octal ascii)
  - (added) new Objects:
            --------
            StringTokenizer: uh string tokenizer (by whitespace)
                (use to be hidden PRC object)
                see examples/string/token.ck

            ConsoleInput: interim console input (until file I/O)
                (use to be hidden Skot object)
                see examples/string/readline.ck

            --------

  - (api)   API additions
            -------- (also see API modifications below)
            ADSR: dur attackTime()
                  dur decayTime()
                  dur releaseTime()
            WvOut: void closeFile()
            Hid: void openTiltSensor()
                 int read( int, int, HidMsg )
            HidMsg: int isWheelMotion()
                    (support for mouse scroll wheels)
                    int key
                    (cross-platform USB HID Keyboard Usage code)
                    int ascii
                    (ASCII value of key, where appropriate)
            --------
  - (api)   API modifications (sorry!)
            --------
            ADSR: float attackTime( float ) -> dur attackTime( dur )
                  float decayTime( float ) -> dur decayTime( dur )
                  float releaseTime( float ) -> dur releaseTime( dur )
            --------
  - (api) deprecated --> new classes
    --------------------------
       HidIn  -->  Hid

  - (fixed) adc.last() now returns correct value (was returning 0)
  - (fixed) array is now subclass of Object
  - (fixed) accessing null array no longer crashes (instead: exception)
  - (fixed) allow: 0 length float arrays
  - (fixed) check for negative array size
  - (fixed) accessing null map no longer crashes (instead: exception)
  - (fixed) connecting null UGen references no longer crashes
  - (fixed) trivial (null == null) no longer evaluated as string
  - (fixed) strict (x,y) => z type checking
  - (fixed) UGens no longer able to make duplicate connections
  - (fixed) && now terminates early if an operand evaluates to 0
            || terminates early if an operand evaluates to 1
  - (fixed) bug accessing static members of built-in classes
  - (fixed) OscSend.startMsg no longer silently fails when 
            using a single string message specification
  - (fixed) Math.atan2 now accepts the proper arguments
  - (fixed) increased OTF command network fail-safe measures
  - (fixed) STK BlitSquare now produces correct frequency
            (applied fix from STK release)
  - (fixed) no longer spontaneously crashes when HidIn and 
            other event based input mechanisms are firing rapidly
  - (fixed) using non-static variables from inside static functions
  - (fixed) variables must be declared before being used


1.2.0.7b (October 2006)
---
  - added: (all) HidIn.name() now returns meaningful device name
  - fixed: (all) fixed STK Envelope bug
  - fixed: (osx) mouse motion now correctly returns delta Y
  - fixed: (win32) joystick hat messages now properly reported
  - fixed: (win32) fixed bug where joysticks of same model/product
           id would send messages through the same HidIn object
  - fixed: (all) seg fault in OSCSend.startMsg() with single 
           string message specification


1.2.0.7 (October 2006)
---
  - (api) deprecated --> new classes
    --------------------------
       sinosc  -->  SinOsc
       triosc  -->  TriOsc
       sqrosc  -->  SqrOsc
       sawosc  -->  SawOsc
     pulseosc  -->  PulseOsc
       phasor  -->  Phasor
          osc  -->  Osc
        noise  -->  Noise
       cnoise  -->  CNoise
      impulse  -->  Impulse
         step  -->  Step
     halfrect  -->  HalfRect
     fullrect  -->  FullRect
         gain  -->  Gain
        zerox  -->  ZeroX
       delayp  -->  DelayP
       sndbuf  -->  SndBuf
         pan2  -->  Pan2
         mix2  -->  Mix2
      onepole  -->  OnePole
      onezero  -->  OneZero
     polezero  -->  PoleZero
      twopole  -->  TwoPole
      twozero  -->  TwoZero
       biquad  -->  BiQuad
         ****  -->  ****
          std  -->  Std
         math  -->  Math
      machine  -->  Machine
    --------------------------
  - (added) --deprecate:X flag
            X can be stop, warn, or ignore - default is warn
  - (added) STK BiQuad get functions pfreq, prad, zfreq, zrad
  - (added) ADSR functions:
            void .set( dur a, dur d, float s, dur r );
            void .set( float a, float d, float s, float r );
  - (added) new UGens (adapted from SC3 Server, Pure Data, CSound)
    --------------------------
          LPF : resonant lowpass filter (2nd order butterworth)
          HPF : resonant highpass filter (2nd order butterworth)
          BPF : bandpass filter (2nd order butterworth)
          BRF : bandreject filter (2nd order butterworth)
       ResonZ : resonant filter (BiQuad with equal-gain zeros)
  FilterBasic : base class to above filters
    --------------------------
  - (added) new HidIn static variables for HidMsg message and device types
  - (added) HidMsg fields to determine device type and number
  - (added) HidMsg functions with capitalization rather than underscores 
            (underscored functions deprecated)
  - (added) .period for all oscillators
  - (fixed) floating point denormals no longer cause potentially
            massive CPU usage on intel processors, this includes
            BiQuad, OnePole, TwoPole, PoleZero, JCRev, PRCRev, NRev
  - (fixed) STK Echo.max no longer gives incorrect warnings
  - (fixed) linux makefiles now respects CC/CFLAGS/CXX (Cedric Krier)
  - (fixed) SinOsc/TriOsc/PulseOsc/SqrOsc/Phasor.sync now unified:
            .sync == 0 : sync frequency to input
            .sync == 1 : sync phase to input
            .sync == 2 : fm synth
            |
      NOTE: the above changes may break/affect existing patches
            using TriOsc, PulseOsc, or SqrOsc
  - (fixed) TriOsc/PulseOsc/SqrOsc phase consistent with convention
  - (fixed) ADSR now handles keyOff() before sustain state
  - (fixed) ADSR now correctly inherits Envelope


1.2.0.6 (more, August 2006))
---
  - (added) support for Mac OS X universal binary
  - (added) executable now reports targets:

  > chuck --version

    chuck version: 1.2.0.6 (dracula)
       exe target: mac os x : universal binary
       http://chuck.cs.princeton.edu/

1.2.0.6 (August 2006)
---
  - (added) support for Mac OS X on Intel: (make osx-intel)
  - (added) win32 - boost thread priority default from 0 to 5
  - (added) Mandolin.bodyIR( string path ): set body impulse response
  - (added) HID: support for mouse input on OS X, Windows, Linux 
              through 'HidIn' class
  - (added) HID: support for keyboard input on OS X, Windows
              through 'HidIn' class
  - (added) new HID examples:
              hid/mouse-fm.ck
                 /keyboard-flute.ck
  - (added) OS X: --probe human-readable MIDI names
              (thanks to Bruce Murphy)
  - (fixed) multiple declarations now behave correctly:
                (example: int a, b, c;)
  - (fixed) now possible to spork non-static member functions
                (example: Foo foo; spork ~ foo.go();)
  - (fixed) sporking fixed in general
  - (fixed) pre/post ++/-- now work correctly
                (example: int i; <<< i++ + i++ * ++i >>>;)
  - (fixed) public classes can now internally reference non-public
            classes in the same file
  - (fixed) obj @=> obj now ref counts correctly
  - (fixed) STK Mandolin.detune( float f ) changed
  - (fixed) STK Mandolin.damping( float f ) changed


1.2.0.5b (April 2006)
---
  - (fixed) adc bug
  - (fixed) %=> bug


1.2.0.5 (April 2006)
---
  - (added) multi-channel audio
            - use --channels<N> or -c<N> set number of channels
              for both input and output
            - use --out<N>/-o<N> and --in<N>/-i<N> to request
              # of input and output channels separately
            - stereo is default (for now)
  - (added) UGen.channels()
  - (added) class UGen -> class UGen_Multi -> class UGen_Stereo
  - (added) UGen UGen_Multi.chan( int )
            use this to address individual channels
  - (added) examples in examples/multi
            - n.ck : n channels detuned sine
            - i.ck : n channels impulse
  - (added) HID support (author: Spencer Salazar)
  - (added) 'HidIn' event class (see examples/hid/*.ck)
  - (added) Terminal Keyboard Input (immediate mode, separate from HID)
  - (added) 'KBHit' event class (see examples/event/kb*.ck)
  - (added) sndbuf.chunks : better real-time behavior
            - can be set to arbitrary integers
              (before the .read happens)
            - default is 0 frames (no chunk)
            - set .chunks to 0 to read in entire file
              (previous behavior)
  - (added) int math.isinf( float ) // infinity test
  - (added) int math.isnan( float ) // NaN test
            (see examples/basic/infnan.ck)
  - (added) sndbuf.valueAt( int ) for returning sample at arbitrary pos
            (see examples/basic/valueat.ck)
  - (added) MASSIVE STK UPDATE
  - (added) 'StkInstrument' class
              .noteOn( float )
              .noteOff( float )
              .freq( float ) / .freq()
              .controlChange( int, float )
  - (added) the following now extend 'StkInstrument'
            (most of them have additional parameters)
              - BandedWG
              - BlowBotl
              - BlowHole
              - Bowed
              - Brass
              - Clarinet
              - Flute
              - FM (and all its subclasses: BeeThree, FMVoices,
                    HevyMetl, PercFlut, Rhodey, TubeBell, Wurley)
              - Mandolin
              - ModalBar
              - Moog
              - Saxofony
              - Shakers
              - Sitar
              - StifKarp
              - VoicForm
  - (added) better STK documentation
            http://chuck.cs.princeton.edu/doc/program/ugen.html
  - (added) examples/stk/modulate.ck
  - (added) --watchdog and --nowatchdog flags
            (very experiment watchdog for real-time audio)
  - (added) () => function; // calls function();
            (thanks to Mike McGonagle for reporting)
  - (added) if exp: ( cond ? if_cond : else_cond )
            (thanks to Mike McGonagle for reporting)
  - (added) math.abs( int ), math.fabs( float ), math.sgn( float )
            (std version unchanged)
  - (added) new examples
              - basic/infnan.ck
                     /fm.ck fm2.ck fm3.ck
                     /valueat.ck
              - event/kb.ck kb2.ck
              - hid/joy.ck
                   /joy-fm.ck
                   /joy-noise.ck
                   /joy-shake.ck
              - multi/i.ck
                     /n.ck
                     /we-robot.ck
              - osc/s.ck
                   /r.ck
              - stk/bandedwg.ck
                   /blowbotl.ck
                   /blowhole.ck
                   /bowed.ck
                   /brass.ck
                   /clarinet.ck
                   /flute.ck
                   /mandolin.ck
                   /modalbar.ck
                   /saxofony.ck
                   /stifkarp.ck
  - (fixed) sinsoc, triosc, sqrosc, phasor:
              - .sync( 0 ) uses input signal to modulate frequency
              - .sync( 2 ) uses input signal to modulate phase
                (FM synthesis)
  - (fixed) impulse.last() no longer has extra samp delay
            (thanks to Mike McGonagle for reporting)
  - (fixed) class inheritance now handles the first overloaded
            function of a parent correctly when called using a
            subclass instance.  in other words, this part sucks
            less now.
            (thanks to Mike McGonagle for reporting)
  - (fixed) (internal) type checker re-instantiation patched
  - (fixed) (internal) detach_all() moved to chuck_globals.cpp
  - (fixed) (internal) global variables moved to chuck_globals.cpp
  - (fixed) file handles close in compiler and parser
  - (fixed) syntax error causing syntax errors


1.2.0.4 (December 2005)
---
  - (added) The ChucK Manual (pdf)
            fantastic work by Adam Tindale and other documentors
            see doc/Chuck_manual.pdf
  - (added) Envelope.duration( dur ), Envelope.duration()
  - (added) Envelope.keyOn(), Envelope.keyOff();
  - (added) PitShift.mix( float ), PitShift.mix()
            (originally effectMix)
  - (added) std.srand( int ) : seed random number generator
  - (added) update to RtAudio 3.2.0 -> much lower latency: Window DS
            (thanks to Gary Scavone and Robin Davies)
  - (added) update to RtMidi 1.0.4 -> improved midi: linux ALSA
            (thanks to Gary Scavone and Pedro Lopez-Cabanillas)
  - (added) bandlimited ugens: Blit, BlitSaw, BlitSquare
            (thanks to Robin Davies for implementation,
             Gary Scavone for putting them in STK)
  - (added) examples/basic/foo.ck foo2.ck tick.ck tick2.ck
            (foo2 shows using Blit, tick.ck is a simple counter)
  - (added) examples/class/dinky.ck try.ck
            (creating and using class to make instruments)
  - (fixed) sndbuf.read now closes file handle and sets curf
  - (fixed) default bufsize=256 under OSX and 512 under all other
  - (fixed) chuck + foof garbled error message
  - (fixed) chuck.lex compatibility under some linux
  - (fixed) waiting on null event: no longer crashes VM
  - (fixed) function arguments: no longer allow reference to primitive types
  - (fixed) function: correctly select overloaded functions w/ implicit cast
  - (fixed) std.atoi() std.atof(): no longer crash on null string
  - (fixed) std.fabs(): now works correctly
  - (fixed) basic/moe.ck larry.ck currly.ck use fabs
  - (fixed) missing base class virtual destructors;
            FreeBSD/g++ compatibility (thanks rasmus)
  - (fixed) most -Wall warnings
  - (fixed) CK_LOG_SYSTEM_ERROR now CK_LOG_CORE


1.2.0.3 (October 2005)
---
  (API changes again)
  (syntax change - 'loop' -> 'repeat')
  - loop( ... ) construct (see 1.2.0.2) changed to repeat( ... )
    - usage and semantics same as before
    - this is also an experimental language feature
      (let us know if it's good or bad)
  - float std.abs( float ) changed -> int std.abs( int )
  - use std.fabs( ... ) for floating point absolute value

  - (added) /* block comments */
    - no nesting allowed
    - closing '*/' not necessary if commenting out rest of the file
  - (fixed) arrays of null object references correctly allocated
      : Event @ events[128];
  - (fixed) DEFAULT sndbuf rate now set correctly to interpolate
      for files outside of chuck sample rate (no longer have to
      explicit do 1 => buf.rate)
  - (fixed) examples/midi/polyfony*.ck no longer creates 128
      unnecessary events...
  - (changed) examples/stk/wurley.ck -> examples/stk/wurley2.ck
  - (changed) examples/stk/wurley.ck (wacky version)


1.2.0.2 (2005.10.17)
---
  (sorry for the API changes)
  - (API change) OSC_Send class name changed to 'OscSend'
      (also): .startMesg(...) name changed to startMsg(...)
  - (API change) OSC_Recv class name changed to 'OscRecv'
  - (API change) OSC_Addr class name changed to 'OscEvent'
      (also): .hasMesg() name changed to .hasMsg()
      (also): .nextMesg() name changed to .nextMsg()
  - (API change) STK Shakers.freq now expect Hz instead of MIDI number

  - (moved) examples/event/opensound*.ck moved to examples/osc/OSC*.ck
      (see OSC_send.ck and OSC_recv.ck for examples on OpenSoundControl)
  - (moved) examples/event/polyfony*.ck to examples/midi/

  - (added) 'loop(...){ }' control structure : 
      example: loop( 8 ) { ... } // executes body 8 times
      example: loop( foo ) { ... } // executes body foo times
      (foo is evaluated exactly once entering the loop, the
      value at that time is used as a constant to control
      loop iteration - even if foo is changed in the loop
      body.)
      - supports break and continue
      - important: one fundamantal difference between the loop 
        semantic and for/while/until semantic is that the argument
        expression 'exp' in loop( exp ) is evaluated exactly once
        when the loop is first entered.
  - (added) MidiIn and MidiOut member functions:
      .good() : whether the thing is good to go (int)
      .num()  : the device number (int)
      .name() : the device name (string)
      .printerr( int ) : whether to auto print errors (default YES)
  - (added) --version command line flag (Graham)

  - (changed) chuck --status now prints shreds sorted by id
      (previously it was the current shreduling order + blocked)
  - (changed) a udp port may now be shared by many OSC_Recv (phil)
      : the incoming messages are broadcast to all
  - (changed) address/type string in OSC: comma now optional (phil)

  - (fixed) events are now 0-sample synchronous (instead of 1)
  - (fixed) startup audio stability for --callback mode
  - (fixed) incorrect 'continue' behavior in for loops
  - (fixed) improved OSC stability (phil)
  - (fixed) OSC shreduling sanity check failed now resolved
  - (fixed) math.round for negative numbers (win32)
  - (fixed) std.mtof and std.ftom now internally double precision 
  - (fixed) removed extra console output in STK Flute
  - (fixed) multiple delete/assertion failure on type rollback
  - (fixed) chuck --kill now closes WvOut and MidiRW file handles
  - (added) examples/midi/gomidi.ck : very useful sometimes
  - (added) examples/midi/gomidi2.ck
  - (added) examples/basic/rec-auto.ck (rec2.ck back in action)
  - (added) examples/basic/fmsynth.ck (from v1)
  - (added) examples/sitar.ck
  - (fixed) examples/stk/*-o-matic.ck now uses array


1.2.0.1 (2005.9.27)
---
  - (added) full callback capability for real-time audio
    - blocking functionality still available
    - select via flags: --blocking and --callback
    - improves latency and stability, especially on linux
    - use --callback (default) for low latency / small buffer size
    - use --blocking for higher throughput
  - (fixed) crash when doing on-the-fly 'replace' : chuck --replace 0 foo.ck
  - (fixed) OSC event function now correctly named ("event")
  - (fixed) removed debug output in OSC
  - (fixed) implicit cast is now correct when sporking (thanks to Manfred Brockhaus)
  - (fixed) examples code reformatted, cleaned, and commented
  - (fixed) nested class definitions can now have same name as outer class
  - (fixed) nested class bug in scan1 (thanks to Robin Davies)
  - (fixed) variable resolution in parent class now visible (thanks to Robin Davies)
  - (fixed) variable resolution ordering
    - local, class, parent, global (thanks to Robin Davies)
  - (fixed) emitter now asserts inheritance instead of equality (thanks to Robin Davies)
  - (fixed) string comparison ==, !=
  - (added) string operations <, <=, >, >=


1.2.0.0 (August 2005)
---
  SYNTAX and OPERATORS:
  - (added) +=>, operator : 2 +=> i; (also) -=>, *=>, /=>, %=>
  - (added) @=> for explicit assignment
    this is the only way to make object reference assignments
  - (added) implicit int to float casting
  - (changed) cast now look like: 1.1 $ (int) => int i;
  - (added) function call by chucking : 
    // call
    (1,4) => math.rand2f => result;
    // same as
    math.rand2f(1,4) => result;

  LANGUAGE:
  - (fixed) type system for existing types
  - (added) forward lookup of classes and functions (mutual recursion)
  - (added) stack overflow detection for massive recursion

  DOCUMENTATION:
  - (added) language specification:
        http://chuck.cs.princeton.edu/doc/language

  COMMAND-LINE:
  - (added) --probe prints all audio and MIDI devices
  - (added) --log or --verbose logs compiler and virtual machine
  - (added) --logN or --verboseN multi level logging
    1 - least verbose
    10 - most verbose

  OBJECTS:
  - (added) 'class' definitions : class X { int i; }
  - (added) 'extends' keyword : class Y extends Event { int i; }
  - (added) virtual/polymorphic inheritance
  - (added) added pre-constructors - code at class level
    gets run when object is instantiated
  - (added) function overloading :
    class X { fun void foo() { }  fun void foo( int y ) { } }
  - (added) base classes (can be extended):
    Object, Event, UGen
    see below
  - (added) base classes (cannot be extended):
    array, string
    see below
  - (added) member data
  - (added) static data
  - (added) member functions
  - (added) static functions

  EVENTS:
  - (added) base Event class : Event e;
    can be used directly
    can be extended to custom events
    (see one_event_many_shreds.ck)
  - (added) waiting on event, chuck to now : 
    e => now; // wait on e
  - (added) e.signal() wakes up 1 shred, if any
  - (added) e.broadcast() wakes up all shreds waiting on e
  - (added) class MidiEvent (see gomidi2.ck)
    alternative to polling.
  - (added) class OSCEvent

  ARRAYS:
  - (added) arrays : int a[10]; float b[20]; Event e[2];
  - (added) multidimensional arrays : int a[2][2][2];
  - (added) associative arrays : int a[10]; 0 => a["foo"];
    all arrays are both int-indexed and associative
  - (added) array initialization : [ 1, 2, 3 ] @=> int a[];
  - (added) .cap() for array capacity
  - (added) .find() test if item is associative array
  - (added) .erase() erase item in associative array

  UGENS:
  - (added) class UGen
    can be extended
  - (changed) all ugen parameters are now also functions:
    // set freq
    440 => s.freq => val;
    // same as...
    s.freq( 440 ) => val;
  - (changed) left-most parameters must now be called as functions
    // no longer valid
    f.freq => float val;
    // valid
    f.freq() => float val;
    // still ok
    440 => s.freq => float val;

  SHREDS:
  - (added) class Shred
  - (added) .yield() .id()

  STRINGS:
  - (added) class string

  AUDIO:
  - (added) stereo
    all stereo unit generators have .left, .right, .pan functions
  - (changed) stereo ugen: dac (2 in, 2 out)
  - (changed) stereo ugen: adc (0 in, 2 out)
  - (added) stereo ugen: pan2 take mono or stereo input and pans
  - (added) stereo ugen: mix2 mix stereo input into mono


1.1.5.6 (2005.4.11)
---
  - last 1.1 release : contains all 1.1 changes


1.1.5.5 (2005.2.10)
---
  - FIFO to RR for audio and synthesis - improves stability on OS X
  - fixed stack underflow emitter bug with declarations
  - fixed cpu sleep bug on win32


1.1.5.4 (2004.11.18)
---
  - fixed clicks when using adc unit generator
    (thanks to paul botelho for testing)
  - added 'maybe' keyword
    maybe == 0 or 1, with 50% probability each

new examples:
  - maybe.ck : the maybe keyword - bad idea? maybe.
  - maybecli.ck : maybe click, maybe not

adc examples work better:
  - adc.ck
  - echo.ck
  - i-robot.ck


1.1.5.3 (2004.11.4)
---
  - when a shred is removed from VM, all children shreds are 
    also recursively removed
    (this fix crash due to removing shreds with active children shreds)
    (to keep children around, put parent in infinite time-loop)
    (this isn't always good - real solution coming soon)
  - 'start' keyword now available - holds the a shred's begin time

updated examples:
  - powerup.ck : start local variable changed name
  - spork.ck : added infinite time loop to keep children active


1.1.5.2 (2004.10.17)
---
  - crtical patch shreduler time precision
  - same as 1.1.5.1 - see below


1.1.5.1 (2004.10.15)
---
  - on-the-fly chuck files to remote hosts!
    > chuck @hostname + foo.ck
    > chuck @hostname -p<N> + foo.ck
  - TCP replacing UDP for commands
  - endian observed (mac <-> win32/linux)
  - more sensible VM output for on-the-fly commands
  - many on-the-fly bug fixes
  - --replace: new shred inherits the replaced shred id
    (useful to keep track of shreds in VM)
  - sndbuf automatically set .rate to 1.0 (instead of 0.0)
    (0.0 => buf.rate if no play on next time advance)
  - new on-the-fly examples

new examples:

  - otf_*.ck - illustrates precise on-the-fly timing
    (adapted from Perry's ChucK drumming + Ge's sine poops)

    chuck them one by one into the VM:

      terminal 1%> chuck --loop
      terminal 2%> chuck + otf_01.ck
      (wait)
      terminal 2%> chuck + otf_02.ck
      (wait)
      (repeat through otf_07.ck)
      (remove, replace and add your own)


1.1.5.0 (2004.9.29)
---
  - now able to write audio files (wav, aiff, raw)
    (try rec.ck and rec2.ck concurrently with any other shreds
     to record to disk)
  - STK file endian is now observed (more things should work
    on little endian systems)
  - added 4 "special" built-in sound samples
    "special:glot_pop" - glottal pulse (flat)
    "special:glot_ahh" - glottal 'ahh' pop
    "special:glot_eee" - glottal 'eee' pop
    "special:glot_ooo" - glottal 'ooo' pop
    (see/listen to moe++.ck, larry++.ck, curly++.ck)
  - all bulit-in sound samples now loadable from both WaveLoop and sndbuf
  - (win32) sndbuf now properly loads wav aiff

new examples:
  - moe++.ck - stooges, evolved
  - larry++.ck
  - curly++.ck
  - rec.ck - run this concurrently to write audio to file
    (also try with -s flag for file out, no real-time audio)
  - rec2.ck - same as rec, but writes to different file every time,
    for sessions


1.1.4.9 (2004.9.18)
---
  - all of STK is now in ChucK!
  - new examples (see below)
  - add '--bufnum<N>' to chuck command line (number of buffers)
  - --status no longer prints full path for source
  - full path now works for command line + (thanks Adam T.)
  - minor bug fixes
  - improved online ugen documentation (go phil!)

new ugens: (again, thanks to Phil Davidson!)
  BandedWG (STK)
  Blowhole (STK)
  BlowBotl (STK)
  Bowed (STK)
  Brass (STK)
  Clarinet (STK)
  Flute (STK)
  ModalBar (STK)
  Saxofony (STK)
  Sitar (STK)
  StifKarp (STK)
  delayp - variable write position delay line

new examples:
  band-o-matic.ck - banded waveguide, automated
  delayp.ck - shows usage
  mode-o-matic.ck - modal bar, happy chaos
  stifkarp.ck - stifkarp, chaos


1.1.4.8 (2004.9.8)
---
  - added win32 visual studio support (chuck_win32.*)
  - new oscillators (see below, thanks to Phil)
  - corrected more issues on some 64-bit systems
  - new examples (see below)
  - chucking to oscillators now able to control phase
    (alternative to doing FM by hand (1::samp at a time),
     see pwm.ck and sixty.ck) (thanks to Phil)

new ugens:
  triosc - triangle wave
  pulseosc - pulse wave oscillator w/ controllable pulse width
  sqrosc - square wave
  sawosc - saw tooth
  phasor - 0 to 1 ramp

new examples:
  sixty.ck - shows osc's
  pwm.ck - basic pulse width modulation
  (you can still do FM "by hand" - see fmsynth.ck)


1.1.4.7 (2004.9.4)
---
  - improved performance (reduce cpu overhead)
  - fixed bug that caused crash on ctrl-c
  - added sndbuf.play (same as rate)
  - corrected issues on some 64-bit systems
  - sndbuf.ck now works


1.1.4.6 (2004.8.26)
---
  - added netin/netout unit generators (alpha version)
  - added a lot of STK unit generators (thanks to philipd)
    (over 80% of STK is now imported)
  - fixed Shakers (thanks to philipd) : examples/shake-o-matic.ck
  - better compilation for cygwin
  - minor bugs fixes
  - added many READ functionality for ugen parameters
       see online documentation at:
       http://chuck.cs.princeton.edu/doc/program/ugen.html

new ugens:
  - netout (alpha version) - audio over UDP (see net_send.ck)
  - netin (alpha version) - audio over UDP (see net_recv.ck)
  - Chorus (STK)
  - Envelope (STK)
  - NRev (STK)
  - PRCRev (STK)
  - Modulate (STK)
  - PitShift (STK)
  - SubNoise (STK)
  - WvIn (STK)
  - WvOut (STK)
  - BlowBotl (STK)
  - FM group (STK)
    - BeeThree
    - FMVoices
    - HevyMetl
    - PercFlut
    - TubeBell

new examples:
  - shake-o-matic.ck - STK shakers going bonkers
  - net_send.ck - oneway sender
  - net_recv.ck - oneway recv
  - net_bounce.ck - redirect


1.1.4.5 (2004.8.14)
---
  - fixed bug for multiple declarations
  - made functions local to shred by default
  - shadowing now works
  - add 'blackhole' ugen for ticking ugens
  - added std.mtof (philipd)
  - added std.ftom
  - added std.dbtorms
  - added std.rmstodb
  - added std.dbtopow
  - added std.powtodb

new ugens:
  - blackhole - the silent sample sucker
  - Wurley (STK)
  - Rhodey (STK)
  - OnePole (STK)
  - OneZero (STK)
  - PoleZero (STK)
  - TwoPole (STK)
  - TwoZero (STK)

new examples:
  - powerup.ck ( (ab)use of TwoPole and sporking)
  - i-robot (building feedback filters)
  - voic-o-form.ck (music for replicants)
  - rhodey/wurley.ck (more stk-o-matics)


1.1.4.4 (2004.8.2)
---
  - added sndfile patch for jack/sndfile (Martin Rumori)
  - added special raw wav for WaveLoop (philipd, gewang)

    (see examples/dope.ck)
      "special:ahh"
      "special:eee"
      "special:ooo"
      "special:britestk"
      "special:dope"
      "special:fwavblnk"
      "special:halfwave"
      "speical:impuls10"
      "special:impuls20"
      "special:impuls40"
      "special:mand1"
      "special:mandpluk"
      "special:marmstk1"
      "special:peksblnk"
      "special:ppksblnk"
      "special:slience"
      "speical:sineblnk"
      "special:sinewave"
      "special:snglpeak"
      "special:twopeaks"

  - fixed shred shreduling ID bug for on-the-fly added shreds (gewang)
  - fixed function resolution for on-the-fly added shreds (gewang)
  - added math.nextpow2( int n ) (Niklas Werner, gewang)

new STK ugens:
  - Mandolin (see examples/mandolin.ck examples/mand-o-matic.ck)
  - Moog (see examples/moogie.ck)

new examples:
  - mandolin.ck (use of STK mandolin)
  - mand-o-matic (fire it up!)
  - dope.ck (Homer's WaveLoop using internal STK sound)
  - print_last.ck (prints last ugen output)
  - wind2.ck (2 shreds control parameters)


1.1.4.3 (2004.7.4)
---
  - add sndfile support (Ari Lazier)
  - add sndbuf file reading/writing (Ari Lazier)
  - add sinosc.sfreq and phase (Phil Davidson)
  - add sndbuf rate and sinc interp (Phil Davidson)
  - add cget functions for unit generators parameters
    (many parameters are readable now)
  - add .last for last sample computed for all ugen's
  - add constants in lib import
  - add math.pi math.twopi math.e
  - add --srate(N) in command line (chuck --help)
  - typing .ck extension optional on command line
  - fixed spork bug involved local variables
  - fixed nested function calls
  - fixed math.min/max bug (Phil Davidson)
  - fixed audio stability OS X (Ari Lazier)
  - fixed MidiOut issue (thanks to n++k)

new Unit Generators
(from STK)
  ADSR (updated)
  BiQuad
  Delay
  DelayA
  DelayL
  Echo
  WaveLoop (updated)


1.1.4.2 (2004.6.14)
---
  - added support for arbitrary audio in/out (via command line)


1.1.4.1 (2004.6.13)
---
  - double lt gt fix
  - added demo[0-5].ck to examples
  - PROGRAMMER updated
  - big/little endian issue fixed


1.1.4.0 (2004.6.12)
---
  - major update to use double float for time, dur, and float
    (this fixes the millisecond bug)


1.1.3.6 (2004.6.9)
---
  - fixed win32 build problem (thanks to Adam Wendt)
  - fixed midi stack problem (thanks to Thomas Charbonnel)


1.1.3.5 (2004.6.8)
---
  - fixed mem stack bug (report Alex Chapman)
  - added jack support (thanks to Thomas Charbonnel)


1.1.3.4 (2004.6.7)
---
  - fixed spork bug
  - bad midiin now returns 0
  - supports sound card with no input
  - add spork.ck


1.1.3.3 (2004.6.7)
---
  - added ability to spork shreds from code
  - casting float/int
  - 0-127 MIDI devices support
  - fix bugs in on-the-fly commands
  - added features to --add, --remove
  - added --time --kill
  - fixed table bug (thanks to n++k)
  - fixed linux makefile (thanks to n++k)
  - added STK ugen: WaveLoop, Shakers, JCRev, ADSR
  - added shred-time synch by T - (now % T ) => now;
---
1.1.3.2
---
1.1.3.1


1.1.3.0 (Spring 2004) --- initial release ---