Friends, ChucKians, artful designers, lend me your ears!
For the past three years, and thanks to a Guggenheim Fellowship, I have
been quietly working on a new book about design and technology, art and
life. The book -- ARTFUL DESIGN: TECHNOLOGY IN SEARCH OF THE SUBLIME
(A MUSICOMIC MANIFESTO) -- explores design as the intersection of art,
engineering, and philosophy. It breaks down computer-mediated
instruments, tools, games, and social experiences in everyday life,
and elaborates 100+ tacit principles of artful design.
It's all in there: ChucK, laptop orchestras, Ocarina, video games,
wacky computer music interfaces, audiovisual design, and a whole lot
more. Published by Stanford University Press, ARTFUL DESIGN was created
entirely in the medium of a (full-color, 488-page) photo comic. This is
a book for anyone who has ever been curious about how we shape
technology, and how technology shapes us.
It's nerdy. It's philosophical. It's a core dump of my brain in comic
form. And it's coming out next week.
See for yourself:
https://artful.design/
The chapters:
https://artful.design/chapters.html
Pre-order the book now, and it will be at your doorstep next week!
https://www.amazon.com/dp/1503600521/https://artful.design/buy.html
Do you know anyone else who might be interested in this book? Please
share this with them!
Keep on ChucKin’ -- and I'll see you in the book!
Ge!
~~~
Ge Wang
Associate Professor
Center for Computer Research in Music and Acoustics (CCRMA)
Department of Music (also Computer Science, by Courtesy)
Stanford University
https://www.gewang.com/
~
Co-founder, Smule
~~~
Dear all,
Hello! I'm happy to announce the initial official release of
Chunity (ChucK for Unity)!
http://chuck.stanford.edu/chunity/http://u3d.as/1bvM
Chunity is the integration of ChucK in Unity. (For those
of you not familiar with the Unity game engine, Chunity gives
you the ability to do realtime sound + music generation natively
in Unity, tightly coupled to interactions with graphical objects.)
You can use most (possibly all?) ChucK features, run new ChucK
code on-the-fly at any time, and communicate between Unity and
ChucK using "global" (new keyword!) ints, floats, strings, Events,
and 1D int and float arrays. (More types to come!) You can even
run multiple VMs that share the same strong timing!
Check out this video of things people have already made with Chunity:
https://vimeo.com/263613454
And check out the original description of Chunity in this NIME paper:
http://chuck.stanford.edu/chunity/files/2018-nime-chunity.pdf
We want to know what you all do with this! Please feel free
to send works in progress, bug reports, feature requests,
finished works, etc. to the chuck-users mailing list!
We are also planning to send a sparse series of follow-up
emails covering tutorials, new features, and cool projects
that people in the community have created.
Please see the tutorials, documentation, etc.
at the official Chunity website:
http://chuck.stanford.edu/chunity/
Thank you and happy ChucKing!!
Best,
Jack + the ChucK team
Music:Computing:Design @ CCRMA
Dear all,
Greetings! chuck-1.4.0.0 (numchucks) is available:
http://chuck.stanford.edu/http://chuck.cs.princeton.edu/
This is a major release of ChucK, and is mostly a massive code
refactor -- huge thanks to Jack Atherton for months of groundwork.
It is now...
1) ...much easier to embed ChucK as a lib/module/component into
other host systems (e.g., Unity... more on that in the coming
weeks); (developers looking to embed chuck: the core engine
can be found in src/core/; the command line host is now in
src/host/ -- also as an example for new hosts)
2) ...possible to support any number of ChucK/VM instances in
the same address space (hence "numchucks")
Please see the release notes at the end of this email and, as
usual, thank you and happy ChucKin!
Best,
Spencer, Jack, Ge and the chuck team
1.4.0.0
---
****************************************************
* MAJOR SOURCE REFACTOR!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
* (Thanks Jack Atherton for months of groundwork!) *
****************************************************
********************************************************
* 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). *
********************************************************
- (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
Howdy,
chuck 1.3.2.0 + miniAudicle 1.3.0 have been released:
http://chuck.stanford.edu/release/
Our first release in a year is an exciting one. In anticipation of a number
of ChucK-based computer music education initiatives (the forthcoming book
"Programming for Musicians and Digital Artists" and Coursera course of the
same name), we have added a number of conspicuously absent features and
libraries, alongside cleaning up a large number of
The most significant change is to formally release chuck as an installer
package on Mac OS X and Windows platforms. These installer packages include
chuck, miniAudicle, related example files, and the standard set of chugins.
(Separate installation of these components is possible but discouraged and
not necessarily supported.) Linux, for the time being, is still released as
separate source distributions.
SerialIO will allow ChucK programmers to easily interact with serial-based
hardware devices such as Arduino. A number of string processing utilities
have been added. Furthermore, the clear.vm command will enable more dynamic
on-the-fly development with public classes.
In miniAudicle, the underlying application core on Windows/Linux has been
completely rewritten in Qt, greatly improving stability and overall
experience. A number of other features and improvements have been added.
Special thanks to Ajay Kapur, Kassen, Mark Morris, Bruce Lott, Fernando
Lopez-Lezcano, and Romain Michon.
Best regards,
Spencer, Ge, and the ChucK team.
chuck
1.3.2.0
---
- (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
miniAudicle
---
1.3.0
- (added) chuck-1.3.2.0
- (added)(Win/Linux) completely new GUI architecture based on Qt
- (added) Clear VM function -- remove all shreds and reset public user
types
- (added) export as WAV + Ogg + M4A (Mac only) + MP3 (if lame exe
present)
- (added) examples browser
- (added) editor tabs
- (added) complex/polar type names highlighted
- (added) highlight chout/cherr
- (added) Class/UGen type names highlighted
- (added)(Windows) .ck file association and double-click to open in
shell
- (fixed) better read-only file handling
- (fixed)(Mac) chugin browser icons not appearing in 10.5/10.6
- (fixed)(Mac) better MAUI stability
- (fixed)(Windows) Windows XP emulation mode no longer required on
Vista/7
Dear all,
chuck-1.3.1.0 (chimera) is available:
http://chuck.cs.princeton.edu/http://chuck.stanford.edu/
ChucK is, at last, 64-bit compatible.
Lack of native 64-bit support has been a long standing issue with ChucK,
and many people in our community over the last few years have contributed
to making this happen. They include Kassen for his ever helpful voice of
reason, Paul Brossier (who did a 64-bit port of ChucK 1.2.0.8 to ubuntu, a
port that this release is largely based upon), Stephen Sinclair, who also
provided a comprehensive and well-executed 64-bit port, and more recently
Robin Haberkorn, who has jumped into the ChucKian development fire, as
well as Michael Wilson -- your initiative and insights have definitely
helped to make this happen. There have been many helpful discussions on
chuck-users and chuck-dev, at CCRMA, as well as much encouragement and
support from friends and colleagues like Fernando Lopez-Lezcano. ... Of
course, had we/I architected the VM instructions to not make integer,
float, and pointer size assumptions in the first place in 2006 with ChucK
1.2, it would have made things quite a bit easier for everyone. Yeah...
Oops.
This is the very first release of ChucK that natively support 64-bit as
well as 32-bit. There are a few additional features (and likely a few
new, uh, "features"). I imagine a few hot-fixin' rapid incremental
releases might be needed. We have tried to test this thoroughly, in
particular on Linux and Mac OS X, and less so on windows. To be totally
honest, we have not been able to even test compilation for 64-bit on
windows - if someone out there with access to 64-bit windows (XP or
Windows7) who can give this a shot, that would be much appreciated! In
general, users of all supported systems, please let us know if/how well
this works for you!
Part 2 -- on the way!
Not unlike the final installment of the Harry Potter movies, or perhaps
the video game ->Final<- Fantasy XIII (there is a FF XIII-2 and what is
effectively FF XIII-3 was just announced), this 1.3.1.0 release will take
place in multiple parts, mostly because Spencer is traveling to ICMC in
Ljubljana, Slovenia, where he will present our paper on Chugins, Chugens,
and Chubgraphs. Also, there is a little bit more work to do for 64-bit
miniAudicle, so that's going to come in CK 1.3.1.0, part 2, and probably
from Slovenia (it seems only fitting to release ChucK from the
international computer music conference). Also, our dear friend Graham
Coleman has asked about a chuck-1.3 version of (gasp) Audicle, so there
might be a 1.3.1.0, part 2, b.
As usual, please see the release notes at the end of this email. Thanks
and Happy ChucKin, UpChucKin, Chugin'! gg!! ChucK on!!
Best,
Spencer + Ge, on behalf of entire chuck team
---
1.3.1.0
- (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 all of 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
* 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)
Hello,
miniAudicle-0.2.0 (gidora) is now available.
http://audicle.cs.princeton.edu/mini/
This release integrates the latest version of ChucK. In addition to
many new ChucK features, this integration fixes a variety of
compilation errors and warnings with recent versions of gcc-4.x, and
also fixes building on Snow Leopard. More importantly, miniAudicle
has officially adopted a newer, more colorful codename, "gidora".
Like Gidora (a.k.a. "King Ghidorah"), miniAudicle is a 3-headed
monster from outer space, who constantly terrorizes the good people of
the planet earth and the universe at large.
Special thanks to Fernando Lopez-Lezcano and Kassen for their bug
requests, feature reports, and other help with this release.
Please let us know about any problems, bugs, feature requests, etc.
thanks,
miniAudicle team
---
0.2.0
- (added)(all) chuck-1.2.1.3
- (added)(Mac) GUI buffer size option
- (fixed)(Mac) Snow Leopard compilation fix
Dear all,
chuck-1.2.1.3 (dracula) is available:
http://chuck.cs.princeton.edu/http://chuck.stanford.edu/
This release, long overdue, introduces experimental/initial support for
file I/O (thanks to many folks who have contributed, including Andrew
Schran and Martin Robinson, both of whom have provided much
implementation and design). Along with the file I/O functionality comes
several new languages features and special objects, including using =>
and <= (the "back-chuck" operator, as Spencer calls it), as well as chout
(stdout, pronounced "shout") and cherr (stderr, pronounced "Cher").
Additionally, a few of function overloading and other issues from the
chuck-users list have been resolved (hopefully). Always, please let us
know of any bugs/features you encounter!
(Please see the release notes at the end of this email.)
Many many thanks once again to Kassen, Inventor, and everyone on
chuck-users, as well as the electro-music chuck forum, PLOrk, SLOrk,
folks at Smule, Fernando Lopez-Lezcano, Carr Wilkerson, Chris Chafe,
Andrew Schran, Martin Robinson, and the rest of the chuck community for
making this release happen!
Thanks and Happy ChucKing, UpChucKing!
Best,
Ge + Spencer, on behalf of entire chuck team
~~~
Ge Wang
Assistant Professor
Center for Computer Research in Music and Acoustics (CCRMA)
Stanford University
http://ccrma.stanford.edu/~ge/
~
Co-founder, CTO, Chief Creative Officer
Smule
http://www.smule.com/
~
http://twitter.com/gewang
~~~
VERSIONS
---
1.2.1.3
- (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
Dear all,
Greetings from the ChucK team - all the best wishes in the coming year!
I want to take this opportunity to bring you up to date on things of
ChucKian nature, and also to address what's next. I hope this reads
more like um cliff notes than a newsletter (because the latter can seem
really boring)!
It has been a fairly insane year for all of us at the ChucK team, ranging
from new research, an expanding community, a new lorchestra, publications
(including a dissertation), to ChucK helping to power a new startup making
crazy sonic software for the iPhone. Here is a partial summary, mostly in
a strongly-timed ordering:
* Continuing our investigation on audio analysis in ChucK: Rebecca, Perry,
and I have begun to explore new directions involving on-the-fly learning
and support for MIR prototyping in ChucK. Check out the all new sMIRk and
publications: http://smirk.cs.princeton.edu/
* PLOrk's west coast offspring/sibling, SLOrk (Stanford Laptop Orchestra)
was instantiated; ChucK is used as the primary platform for instrument
design, sound design/synthesis, and teaching:
http://slork.stanford.edu/http://slork.stanford.edu/media/
* By the way, PLOrk is about to enter a new level of insanity in spring
2009, with an MacArthur-supported campaign that features an fully
expanded, rebuilt ensemble and an unbelievable lineup (Matmos, So
Percussion, and Laurie Anderson):
http://plork.cs.princeton.edu/
* PhD Dissertation: "The ChucK Audio Programming Language: An On-the-fly,
Strongly-timed Environ/mentality" was completed, almost fatally injuring
its author and his PhD committee in the process:
http://www.cs.princeton.edu/~gewang/thesis.html
* Smule was found in Summer 2008, exploring what we call "Interactive
Sonic Media", starting with the iPhone. ChucK on the iPhone (ChiP) serves
as the core platform and engine. Perry, Spencer, Rebecca, and I are all
part of the madness:
http://www.smule.com/http://www.smule.com/about/http://ocarina.smule.com/http://www.youtube.com/watch?v=kfrONZjakRY&fmt=18
* Meanwhile, the ChucK community continues to grow both in and out of
academia. We especially would like to call out the inspiring efforts of
Kassen (sporksperson, forum moderator, and ChucKian sherpa), Inventor,
Stephen Sinclair, Ajay Kapur, Adam Tindale, Paul Botelho, Dan Trueman,
PLOrk/SLOrk, and others for the immense guidance, ideas, and creativity
they provide on the forum, mailing lists, as well as in classrooms and
onstage.
---
>From our point of view, it has indeed been a busy year of ChucKing.
What's next?
* One common question concerns ChucK on the iPhone. Here is where things
stand: ChucK has ported to the iPhone by Smule, and has served as the
audio platform behind its products (Sonic Lights, Ocarina, etc.). While
ChucK is freely available on OS X, Linux, and Windows (and shall remain
so), we have not yet opened ChiP, our ChucK on iPhone engine/port (nor do
we license this platform currently). While we can't make any promises, we
articulate that the core team would like to explores ways to open ChiP by
creating an beneficial environment for everyone (researchers, artists,
smule, developers). Again, we can't make any promises and it is a
possibility that ChiP will not be open sourced for the foreseeable future,
but we genuinely want to make it open and make it work, and are exploring
that possibility.
* Along this line, we would like to articulate the following point: major
general language features that are introduced as part of ChiP *will* be
fully released in the main distribution (only iPhone/smule-specific
features will remain proprietary for now). This is by design when we
structured Smule. You see, most of us at Smule care about, use, and
release open-source software, and we genuinely want to build an ecosystem
where things can be as open as possible and remain mutually beneficial.
We shall keep moving forward in this way.
* ChucK releases: it's been a while since the last release, so perhaps
not many are holding their breath for the next release. It's coming, for
better or for worse!! File IO is finally in place, along with several
other features. miniAudicle MAUI for Windows and Linux are nearing
completion as well. Stay tuned!
* ChucK research, development, and pedagogy continues in full, at
Princeton, Stanford, and with quite a few other institutions and
individuals. Rebecca leads the charge on MIR/on-the-fly
learning/analysis-based performance, new features/uses are developed
by Perry, Dan, researchers and students at Princeton, and by us at CCRMA,
and now at Smule. At Stanford, we are also working on new systems based
on ChucK, code, and interaction to provide new ways of working with
audio. Stephen Sinclair, Kassen, Inventor, Ajay Kapur at CalArts, and
Adam Tindale in Calgary continue to contribute code and ideas.
Admittedly, incorporating contributions has been an issue, and this is
squarely my fault for not having better coordinated due to cycle
shortages. For what it's worth, I am just going to accept that the load
not going to get any better and will endeavor to re-organize!
Well, that's all I have for now - and it's amazing if you read this far!
Please send all thoughts, complaints, suggestions to the chuck-users
list, forum, or just email us!
>From all of us on the ChucK team, we wish you a wonderful new year and
beyond!
All the best,
Ge, on behalf of ChucK team
Hi,
Apologies for cross-posting.
Forwind invites musicians/software developers/artists who write custom audio
software to submit both a piece of music created with the software and the
software itself for inclusion in an audio and software compilation due to be
released mid 2009.
This compilation will strive to present both the software and audio on an
equal footing. Design of the end package will be in the very capable hands
of Paul Finn from Fitzroy & Finn (www.fitzroyandfinn.co.uk). The intentions
are for this to be a substantial physical release (Book, double CD etc -
details have yet to be finalized.)
Software may but not necessarily need to include patches/code from
PureData/Max MSP, Supercollider, Chuck, CSound, Faust, CLM, Snd-Rt, VSTs,
Ladspa's, Processing, bespoke sound apps (C/C++, python, ruby, fortran,
assembly!) et al ...
Please send submissions to
Forwind Comp.
36B Bodney road,
London,
E8 1AY,
U.K
Deadline 2009/03/31
more details @ www.forwind.net/home/call_for_work
Nice holiday all !
Best regards,
Conor J Curran
Greetings all,
There have been some confusion (mostly caused by me) as to the
intended purposes of our mailing lists, occasionally even leading
to folks wondering if the ChucK project is still going. Here are
some clarifications and updates.
* the ChucK project is going strong, perhaps more so than ever, with
researchers/developers at Princeton, Stanford, and many other places
around the world; it's being used as a primary software platform in
PLOrk/SLOrk, and is being integrated into increasing numbers of
curriculi. The "ChucK => MIR programming" workshop at the upcoming
ISMIR already has 40 registrants; The user base seems to be growing
steadily.
* As for the mailing lists:
[chuck] (this list) has long been converted into a place for
announcing important updates, and high-level discussions.
it is moderated; specific questions, answers, discussions
should be directed elsewhere (see below)
[chuck-users] is an unmoderated list for specific questions,
discussions, suggestions, and diatribes - a place where
folks are encouraged to provide constructive help, and to
call others (in particular, me) idiots. Go for it!
the web forum (http://electro-music.com/forum/forum-140.html)
is an excellent place/way to get/provide help.
One can access all of the above from:
http://chuck.cs.princeton.edu/community/
I hope this helps! Please feel free to write me, or continue
this discussion on [chuck-users] and/or the forum. Most messages
to this list likely won't go through.
Thank you and sorry for the confusion!
Yours,
Ge!
