New in 2015.11:
 + Features
   + Initial shaped array support
   + \r\n (Carriage Return/LineFeed) is now a single (synthetic) grapheme
   + Unicode support adheres to Unicode Annex #29
   + New IO::Handle.nl-in now allows multiple line-endings to be set
   + New IO::Handle.nl-out allows you to set line-ending used in IO::Handle.say
   + New IO::Handle.split/comb, same feature set as Str.split/comb, but lazy
   + IO::Handle.seek now accepts new SeekType enum values as 2nd parameter
   + New $?NL contains the output new-line character(s) for the current system
   + New 'use newline' pragma allows setting of $?NL
   + New List.head/tail methods for easier getting first/last N elements
   + New List.repeated for only getting repeated values in a list
   + Str.encode now allows :replacement parameter for unencodable sequences
   + Str.split now accepts multiple strings to split on
   + Str.split now accepts :v, :k, :kv, :p, :skip-empty named params
   + Str.comb(Int:D $n) candidate allows for combing string per $n characters
   + New Range.int-bounds returns first/last value for integer ranges
   + EVAL now passes on named params, to allow for customised EVAL subs
   + Auto-generated meta-ops vivified by referring to them, instead of executing
   + Unicode quotes are now also allowed in regular expressions
   + Can now coerce to generic types in parameters
   + Can attach adverbs to variables
   + Illegal assignment of different Numeric values now caught at compile time
   + &nextcallee implemented, which returns the routine that nextsame would invoke
 + Deprecated
   + IO::Handle.nl should either be IO::Handle.nl-in or .nl-out
   + IO::Handle.seek with a numerical value for 2nd parameter
   + Str.split( ... :all) should be written as :v
 + Fixes
   + RT #74414: the multi dispatcher now treats "is rw" parameters as tighter matches
   + RT #125123: improved error message for type check failures in int-typed arrays
   + RT #126436: improved error message for missing required attributes
   + multi submethods aren't inherited to subclasses
   + leading escape sequences representing whitespaces aren't stripped anymore from  heredocs
 + Speedups:
   + [+] and sum
   + Blob.subbuf
   + List.sort
   + List.roll
   + List.rotate
   + List.reverse
   + IO::Handle.getc
 + Build system
   + New options --sdkroot and --sysroot to Configure.pl to support cross builds

New in 2015.10:
 + Features
    + We are now officially in beta!
    + There is now an infix:<.> operator that does method calls with slightly
      looser precedence than the postfix unary method call.
    + Definite return values are now allowed, and force final statement to sink
    + Types with type smilies (like 'Int:D' and 'Int:U') are now first class,
      and supported in constraints for variables, for example
    + New pragmata 'use variables :D', 'use attributes :D' for defaulting type
      constraints to ':D'
    + The 'constant' declarator now supports syntactic constructs, so you can
      alias with 'my constant &infix:<plus> := &infix:<+>;'
    + New operator 'infix o' for function composition
    + New method 'produce' for triangle reduce
    + 'fc' for Unicode-correct case folding implemented
    + '<?same>' assertion in regexes implemented
    + Methods 'file' and 'line' in 'Code' point to the location of the
       declaration
    + grep now accepts :k, :v, :kv, :p attributes
    + first now accepts :k, :v, :p attributes
    + first also accepts :end attribute to indicate searching from end of list
    + 'is equiv<+>' as shortcut for 'is equiv(&infix:<+>)'. Same for 'tighter'
       and 'looser'.
    + 'Supply.throttle' for rate-limiting
    + 'Hash.append' added, now that Hash.push doesn't flatten
    + Internal methods ZEN-POS/ZEN-KEY added, for handling zen-slices
    + Promise.start now passes on any extra parameters to async block
    + Use of comma in sink context now distributes sink to its parts
    + Attribute containers may now have defaults
    + The new .self method is the identity method on anything
    + Negative integers are now allowed in the parameter slot
    + List associative operators can now be autoprimed, including Xop and Zop
  + Incompatible Changes
    + Array.push is now used for pushing one element (mostly); Array.append
      exists for pushing multiple values. Same for 'unshift'/'prepend'
    + Basic arithmetic operations ('+', '*', '-', '/') on Range objects
      that shift or scale the end points while maintaining exclusions
    + 'is rw' now only works on scalars (was a noop), and actually requires
      a writable container. Parameters of the form '\x' enable the old
      behavior
    + The v notation now allows alphabetic components: v1.2.beta.  (Incompatible
      because method calls on a version must be protected by \ or () now.)
    + 'use v6b+;' notation is now recognized and enforced
    + Many list functions no longer flatten, or use one-arg flattening only
    + The sequence operator no longer flattens sublists, so you must use slip
      to get that effect
    + The precedence of infix:<.=> is now tighter to match new infix:<.>
    + Smartmatch with List now recursively uses smartmatch
    + Smartmatch with list now globs using '**' rather than '*'
    + callwith/nextwith no longer flatten
 + Speedups:
    + Many built-in methods that return iterables are now much faster
    + 'Bag' and 'Mix' are now faster
    + Rat addition/subtraction is now faster due to lazy reduction when
      consistent denominators are used ("cents stay cents")
 + Fixes:
    + Better error messages when comparing version strings with numbers
    + Several error messages that were lacking line numbers now include them
    + Anonymous types now compare correctly under 'infix:<===>'
    + Fixed 'once' block semantics (RT #126293)
    + A dying 'LEAVE' block doesn't prevent other 'LEAVE' blocks from running
      anymore
    + 'Str.tc' now does an actual Unicode title case operation
    + polymod had not been GLRified yet
    + List/Supply.squish did not properly handle single element lists/supplies
    + Several fixes to the REPL, e.g. with regards to completions
    + with/without now topicalize properly
    + Fix usage of match variable in replacement part of substitution
    + ».[1;1] (hyper on multidim subscript) now works
    + Methods map, push, pop, shift, unshift, append, prepend now properly
      marked as nodal
    + Attempt to smartmatch with S/// now warns
    + grep { /foo/ } now dwims again
    + Operator names now canonicalize internally to legal Perl names
    + Reduction ops now generalize to N-ary functions
    + Extra list comma is now allowed before any statement modifier
    + Various multisubs now report .arity more accurately
    + Exceptions can now correctly report the Nil type
 + Deprecations:
    + grep-index() deprecated in favour of grep(:k)
    + first-index() deprecated in favour of first(:k)
    + last-index() deprecated in fevour of first(:end,:k)

New in 2015.09
 + Features
   + Great List Refactor
   + New slurpy parameter, +args or +@args, to allow for one-argument style binding
   + New with/orwith/without conditionals allow you to check for .defined but
     topicalize to the actual value returned
   + New 'supply', 'whenever' and 'react' blocks for easy reactive programming
   + Mu.return implemented: allows for ".return with $foo"
   + Cool.indices/indices() expands on Cool.index/index() functionality
   + Callframes now allow easy introspection of associated Code object
   + Test.pm now has a 'does-ok' function for testing role conformance
   + '$¢' in grammars now refers to the current cursor
   + All Unicode digits can now be part of literal numbers
   + 'val()' and allomorphic types implemented
   + Most European quoting styles are now supported
   + The parser now detects and reports possible runaway quotes
   + New $[...] and ${...} constructs allow prefix itemization
   + 'dd' now displays variable type
 + Fixes:
   + Using a Range with an infinite .max now works on substr()/.substr
   + Parameter aliases are now handled in MAIN subroutines
   + Fixed typo about environment access in IO::Spec::Cygwin.tmpdir
   + Blocks like { .foo } are no longer considered to be a Hash constructor
   + Propagate ignorecase into subrules of regular expressions
   + eqv no longer defaults to === semantics, but snapshot (via .perl)
   + A constant declaration now pays more attention to its sigil
   + The .gist and .perl methods can now deal with self-referential structures
   + andthen and orelse are now topicalizers as specced
   + Fixed CompUnit.load, which is what use/require uses under the hood
 + Incompatible changes:
   + Creating constants with a ? twigil has become a NYI for now
   + No longer allowed to create dynamic constants with "my constant $*FOO"
   + Forbid to use the very same variable to init itself directly in declaration
   + Parcel is no longer a type, use List instead
   + 'is parcel' trait is now 'is raw'
   + .gist now puts brackets around lists and arrays
   + IO::Handle::lines no longer returns an empty last line
   + The 'Enum' type is gone; use 'Pair' instead.
 + Deprecations:
   + All Deprecations removed in preparation for Christmas release
 + NativeCall:
   + Added support for calling into C++ libraries and calling methods on
     C++ classes

New in 2015.07
 + Features:
   + Cool.substr(-rw) and &substr(-rw) now also accept a Range
   + Added trait "is required" on class attributes
   + Parameters like :n($n) are presented as :$n in .gist
   + &?ROUTINE and &?BLOCK
   + Conversion forms now understand :16(':8<377>') and such
   + &words implemented (to completement .words)
   + Numeric comparison ops (== > etc) for DateTimes
 + Fixes:
   + ENTER phaser now can be used as an r-value
   + Allow %{Type} as a way to say Hash[Any,Type].new
   + Several issues with the use of ';;' in signatures
   + Issues with regexen throwing an exception (RT #62086 & #72440)
   + samewith() now also works in subs
   + Calling the .clone method with alternate values no longer changes original
   + Various fixes and optimizations on List.splice
   + .grep and &grep now consume multiple elements for many-param blocks
   + Issues with precedence limit checking in EXPR fixed
   + EVAL now pays attention to languages in the compiler registry
 + Incompatible changes:
   + my Type $a is default($value) is now compile-time checked
   + my $a is default(Nil) only works on untyped (Mu) variables
   + Can no longer (roulette) assign to Whatever slice of a hash
   + Emit warning when \$ \@ \% \& are used to create a Capture
   + Now illegal to use a contextual ($*c) before declaring it in a block
   + EVAL :lang<Perl5> instead of <perl5> for consistency with use :from<Perl5>
 + Deprecations:
   + $*PROGRAM_NAME in favor of $PROGRAM-NAME
   + $*EXECUTABLE_NAME in favor of $EXECUTABLE-NAME
   + pipe() in favor of shell() or run() with :in, :out or :err

New in 2015.06
 + Features:
   + Lexical pragma 'use trace' now outputs statements on STDERR
   + $=finish now contains text after first =finish/=for finish/=begin finish
   + __END__/__DATA__ now marked as obsolete Perl 5 features
   + Added :as named param to .classify / .categorize
   + EVALFILE added, for evalling source in a file
   + Implemented 'quietly' statement prefix to prevent warnings being issued
   + MinGW (Windows with gcc/gmake) is now also supported besides MSVC
   + Implemented 'has Type method'
   + Implemented Buf.push
   + Implemented S/// (returns the new string rather than in-place substitution)
   + Implemented X::StubCode for .../!!! code
   + Add :createonly to rename()
 + Fixes:
   + (10e6).pick/roll no longer build the whole list to pick a value
   + Regex.gist/perl return source of regex
   + start now takes a statement also, or a block (as before)
   + .push/.unshift on typed arrays now create the right type of container
   + Throwing a Failure counts as handling it
 + Incompatible changes:
   + DateTime default timezone format is now +HH:MM (used to be +HHMM)
   + "".IO / IO::Path.new("") no longer legal, use "." for current dir
   + next/last/redo don't allow expressions to be evaluated anymore
   + sign(NaN)/NaN.sign is now NaN
   + Stubbed-out code (via .../!!!) no longer results in X::AdHoc
 + Deprecations:
   + Using start as a sub with parentheses, e.g. start( { ... } )
   + open(:p)

New in 2015.05
 + Features:
   + NFG, NFC, NFD, Uni
   + Implemented unicode property pairs with explicit arguments, e.g.
     <:NumericValue(0 .. 1)>, <:Name(/LATIN/)> etc (MoarVM only)
   + :m/:ignoremark implemented (now that we have NFG)
   + Implement <&foo: $arg>, <&foo($arg)> and my $a = "alpha"; /<::($a)>/
   + List/Supply.rotor expects a list of Pairs (elems|elems => gap)
   + Added much faster List.pick(*,:eager) variant
   + Implemented CLIENT:: (nearest CALLER:: from different package)
   + Normal stacktraces no longer include references to code in settings
   + RAKUDO_BACKTRACE_SETTING to *do* include code in settings
   + RAKUDO_VERBOSE_STACKFRAME environment variable shows source lines
   + Warnings now show file/line unless the end with a newline
   + Implemented "is nodal" for signalling behaviour under hypers
   + Rudimentary tab completion available via the Linenoise module
 + Incompatible changes:
   + The readline integration that existed on the VM level has been removed;
     it now exists as a module.  To restore readline operations in the REPL
     (ex. history, line control), install the Linenoise module via Panda
   + "unit" declaration needed for blockless packages
   + Various API changes for the Great List Refactor, such as...
   + 'for' loops not longer flatten; use 'for flat' for that
   + .map no longer flattens, map as a listop does. Use .flatmap to get the
      old behavior
   + Likewise other methods that used to flatten their invocant no longer do:
     all, any, one, none, unique, squish, min, max, minmax, classify, and categorize
   + Nil no longer iterates like the empty List. Use () or Empty instead.
   + Hashes no longer maintain insert order on Moar (on JVM they never did)
   + @*INC now contains strings (again), rather than CUR objects
   + Item seperator in INC spec is now ","
   + Type / info seperator in INC spec is now "#"
   + .pick($n)/roll($n) now always return lists, even when $n == 1
   + $?FILE is now always an absolute path
   + Variable will init/post/compose throw NYI instead of silently doing nothing
   + The "is cached" trait no longer works on methods, throws a NYI instead
 + Deprecations:
   + Method .map should be used instead of .for
   + List/Supply.rotor now *must* have elems and gap specified
   + Test.pm functions are now kebab-cased (e.g. throws_like -> throws-like)
   + in regexes, avoid non-significant whitespace between alphanumerics
   + Unhandled Failure leaks are now warned about if detected by DESTROY
 + Fixes:
   + Many race conditions, specifically wrt to role specializations
   + Hashes use much less memory on Moar
   + my $a will begin/enter/leave/keep/undo/first/pre now set $_ properly
   + List.roll(Inf) now knows it's infinite, so is lazy
   + The REPL is strict by default now, that leaves only '-e' lines to be lax
   + Undeclared variable compile time error made clearer
   + IO::Handle.lines(:eager)/.words(:eager) now properly eager again
   + 'earliest' now handles remaining channels without specific handlers
   + Int/Rat ** -Int now generates a Rat if possible, else a Num
   + IO::Path.resolve now returns IO::Path as specced
   + CALLER now produces consistent results in the dynamic scope of implicit protos
   + A regex may now be used as the smartmatch of a sequence operator
   + Fix /a ~ (c) (b)/ capture order bug.
   + map <:alpha> in regexes etc to proper lookup on JVM
   + site/lib is now in the C library (.dll/.so/.dylib etc) search path
   + Fix scoping bugs with statement modifier for and given.
   + Make { 1 R=> 'a' } and { %*h } construct hashes.
   + Fix lexical context of regex interpolations
   + Various list ops now report .is-lazy correctly
 + Speedups:
   + generating backtraces is now lazy, improving the speed of e.g. warnings
   + Make List.pick about 3% faster, List.pick(*) about 7% faster
   + Implement new @*INC handling (about 30% faster startup time)
     (bare startup time is now below 100 ms on some machines)
+ NativeCall:
   + Implemented CUnions which map to the union C type definition
   + Implemented HAS declarator for attributes to mark it embedded into the
     CStruct or CUnion

New in 2015.04
 + Incompatible changes:
   + Installation directory layout changed: it now uses $PREFIX/share instead of
     $PREFIX/languages
   + "0" (0 as a string) is now True, no special-casing anymore
   + an Int() coercion type in a multi now creates two candidates: Any and Int
 + Fixes:
   + try now implies "use fatal", so failures are not leaked
   + "use fatal" now only works in its scope, and not in deeper ones
   + don't constant-fold Failures
   + throws_like will EVAL code in context of caller
   + pragma's like "strict" can now also be called with -M on the CLI
   + once a List is infinite, it will stay infinite (fixes several hangs)
   + can now slice an Infinite list into a finite slice
   + can now slice a finite list into an infinite slice
   + adverbs are now allowed inside a ternary
   + auto-generated accessors will not show up in backtraces anymore
   + $_ now defaults to Any, rather than Nil
   + intuited iterators no longer bypass endpoint if no exact match
   + intuited iterators may also skip literal values if endpoint is lower
   + intuited iterators beginning/ending with same length now according to spec
   + say now observes the .nl setting
   + exceptions in BEGIN blocks and constant are now handled better
   + binding now works again in the REPL
   + various other REPL fixes
   + \foo variables work properly in EVAL
   + declarations like my (Str $ing, Int $eger) correctly enforce types
   + detect and complain about placeholders in attribute initializers
   + use of | prefix in the wrong place now complains at compile time
   + \(...) capture constuct handles nameds and | correctly
   + regex interpolation now uses cursors instead of scanning
   + correct line numbers are reported for faling tests
 + Deprecations:
   + the RC release in September will remove *all* deprecations
   + "use nqp" now required for silent use of nqp::ops
 + Features:
   + native arrays
   + 'bit' and 'byte' native types
   + starts-with/substr-eq/ends-with for comparing strings inside other strings
   + first steps towards generic lexical pragma's (e.g. soft, strict, nqp)
   + basic implementation of Uni, NFC, NFD, NFKC, and NFKD on Moar backend
   + Uni.Str coercion produces an NFG string
   + chop now takes optional number of characters argument
   + where constraints on variable and attribute declarations
   + dists are installed into a database-like way by default (via panda)
   + 'is rw' parameters implemented for native subs (they get passed as a pointer)
   + complex and rat literals now work inside of a <> quote
   + attempting to bind a Failure now tells you what was in the Failure
   + reduce() now pays attention to associativity (which is now part of the op)
   + can now reduce ([Z]) with list infixes over an arbitrary number of lists
   + use Foo:from<Perl5> supported when Inline::Perl5 is installed
   + EVAL $code, :lang<perl5> supported when Inline::Perl5 is installed
 + Speedups:
   + Str.codes/chars/uc/lc/tc/tclc/ord/flip about 25% faster
   + List.pick about 10% faster
   + Mu.clone about 8% faster
   + make xx about 1.8 times faster
   + several speedups in matching
   + numerous Num.Rat optimizations: 6.5x faster

New in 2015.03
+ Incompatible changes and deprecations:
  Any code *calling* the old method names, will be given a deprecation warning,
  and will continue to work. Any module that *implements* MMD candidates for
  any of these methods with their old name, will probably break. Please start
  using the new names as described below.
  + renamed internal hash/array/code/* methods:
    - OLD                    NEW
    - at_pos                 AT-POS
    - exists_pos             EXISTS-POS
    - delete_pos             DELETE-POS
    - assign_pos             ASSIGN-POS
    - bind_pos               BIND-POS
    - at_key                 AT-KEY
    - exists_key             EXISTS-KEY
    - delete_key             DELETE-KEY
    - assign_key             ASSIGN-KEY
    - bind_key               BIND-KEY
    - invoke                 CALL-ME
    - Supply.on_demand       Supply.on-demand
    - Supply.schedule_on     Supply.schedule-on
  + renamed traits
    - hidden_from_backtrace  hidden-from-backtrace
    - hidden_from_USAGE      hidden-from-USAGE
  + Deprecated use MONKEY_TYPING for use MONKEY-TYPING.
  + Incompatibility change: spaces are no longer allowed in operators.
  + Disallow redeclaring constants in the same scope
  + Throw redeclaration error for duplicate type capture
  + Deprecate IO::Handle.input-line-separator for .nl
  + Remove parrot support from Rakudo.
  + Don't print deprecation messages if RAKUDO_NO_DEPRECATIONS env var is set
+ Features
  + Allow Buf.AT-POS to return an l-value.
  + Implement method ^foo($) { ... } syntax.
  + Implemented PairMap (the simple case only, for now).
  + Implemented .antipairs (pairs with value => key).
  + Implemented .pairup for creating pairs from lists.
  + Implemented LEXICAL, OUTERS and CALLERS pseudo-packages
  + Implemented UInt (sub)type and coercer.
  + Add a array[T], usable for native int/num (MoarVM only for now)
  + Other native improvements, e.g. my int $a; $a++
  + Smart quotes (as in “foo”,  ‘bar’, ‚baz’ and „zap”) now also supported.
  + Improve and test support for Listy types in JVM Interop.
  + Hyper-infixes (like »~») are faster and have more features.
  + Make token prefix properly compete with term in LTM
  + not() and so() are functions as well as prefixes.
  + substr-rw() now accepts the same range of parameters as substr()
  + keywords now require whitespace (unless shadowed), which allows:
    my \if = 42; say (if) if if; # now says 42
  + Implement IO::Path.resolve on r-m/POSIX
  + Catch P5ish use of $/
+ Fixes
  + Catch wrong attribute usage in a regexes.
  + Fix compiler warnings on OS X / JVM backend
  + bare say now complains about no valid arg
  + Make <a b c>.invert no longer infiniloop
  + Make List.kv completely flatten its values
  + Update error message for $] to use $*PERL.version
  + Fix JVM runner generation on Windows.
  + fix $*KERNEL.arch for raspbian, ugexe++
  + Make $?TABSTOP immutable
  + Make CALLER::<&?ROUTINE> work
  + Errors like "expected Array[Str] but got Array[Str]" have been fixed.
+ Optimizations
  + Make my int/num @a = Range about 1000x faster
  + Make generic Str.subst between 5 - 10% faster
  + Make s/// up to 25% faster (for many changes)
  + Make Bool.pick and Bool.roll up to 2x faster
  + Make Bool.pick()/roll() another 10% faster
  + Make substr(-rw) about 10% faster
    + substr("foo",1)       2.5x faster
    + substr("foo",1,2)     6x faster
    + substr("foo",*-2)     1.5x faster
    + substr("foo",0,*-2)   1.5x faster
  + Make %h<a> = 42 about 10% faster
+ Test.pm changes
  + Several improvements in Test.is() wrt to handling type objects and whitespace.
  + Add simple use-ok implementation
+ NativeCall.pm changes
  + 'is native' will also accept Callables to allow runtime library detection
  + Implemented nativesizeof(T)
  + Add typed Pointer type as replacement for OpaquePointer
  + Throw exception for wrong arity in native subs

New in 2015.02
+ Overriding invoke/postcircumfix:<( )> for type coercions (ex. MyType(...))
  now passes the function arguments as-is, rather than just passing a Capture
  containing them
+ optimizations to slices with adverbs
+ improved error messages from sprintf and fmt
+ improved error message when trying to inherit from a class that isn't
  composed (like a stub)
+ Proc::Async polished (improved error reporting, relaxed type constraints)
+ LoL assignment is now autovivifying
+ Semicolon/"rest of file" form of the MAIN sub implemented
+ Parsing for infixes like "$foo !and $bar" or "$foo !&& $bar" fixed
+ Coercion syntax for parameters: sub foo( Str(Any) $x ) { ... }
+ Str(Any) as a term now parses as a coercion type
+ Foo() works as a coercion type shortcut for Foo(Any)
+ Metaop "=" now respects the precedence of the op it's meta-ing
+ Enable term definitions via "my", e.g., "my \term:<∞> = Inf"
+ Added "polymod" method on numerical values
+ Made simple Str.trans / tr///, Str.subst about 20x faster
+ File test operators now follow symlinks on systems that support them
+ New method Rational.base-repeating, optional precision argument for Real.base
+ Blob.bytes now returns actualy byte size, even for non-byte blobs
+ "6;" at unit start is no longer a way to say "no strict;"
+ Anon variables in sink context warn now correctly
+ Buffer types can now be passed to C functions via NativeCall
+ C types like "long" that depend on the architecture are now handled correctly
+ NativeCall is now shipped with rakudo, because it is coupled too tightly
+ Allow "constant" and "has" declarations to be initialized with .=
+ Types constructed for mixins ("does" and "but") are now cached, giving a 10x
  speedup on repeated mixins of the same role to the same type and cutting
  CORE.setting size down (by 700KB on MoarVM, for example)
+ Made .^can(...) aware of submethods
+ Fixed a pre-compilation bug when a multi-method in a subclass was installed
  in a cloned proto-method inherited from the base class, then called at BEGIN
  time

New in 2015.01
+ New simple way of creating an object hash: :{}
+ Str.substr-rw was omitted before, it isn't anymore
+ The loop ^1000 optimization is working again
+ Pair.gist has been simplified (a => 42, rather than "a" => 42)
+ Exporting an Enum now also exports its values
+ Proper error handling for a placeholder that has already been used as
  non-placeholder in the same scope
+ Sub form of 'unique' introduced, 'uniq' deprecated
+ Supply.for deprecated in favour of Supply.from-list
+ All deprecated features will be removed with 6.0.0 (sometime in 2015)
+ Startup on the JVM has improved by 20%
+ Many improvements to Java interop for the JVM backend
+ Several precomp issues have been solved
+ Better error messages for die(Failure)
+ Fixed CATCH/CONTROL blocks in the program mainline
+ Substitution now supports assignment meta-op, e.g. s[\d+] += 2
+ Many memory and CPU optimizations

New in 2014.12
+ Flakiness on OS X has been fixed
+ Support for Increase/Decrease, bless(*,...) removed, were deprecated 1+ year
+ Method FALLBACK implemented
+ $str ~~ s/// now returns a Match or list of Matches
+ Updated List smart-matching to latest design
+ $*DISTRO and $*KERNEL updated ($*DISTRO now actually report the Linux dist)
+ Most, if not all, signals are now supported everywhere (MoarVM only)
+ Configure.pl: Fixed check for outdated nqp-m; warn on missing --prefix
+ Optimizations of integer division and Rat construction
+ Added Metamodel::Primitives, to open up more meta-programming possibilities
  (publishing method caches, completely custom meta-objects, etc.)
+ Support for closure parameter signatures
+ Implemented chained sequences
+ Implemented longest literal LTM tie-breaker
+ Calling "close" on a Supply will now close all of its taps
+ Added "extension" method to IO::Path
+ Fixed bare "slurp", it was broken in 2014.11 or before

New in 2014.11
+ using a constant negative subscript now dies at compile time
+ better wording for runtime negative index failure
+ force calling method for <.foo> even if sub foo exists
+ fix tie-breaking issues with longest literal matching
+ make List.last-index non-lazy (as the whole list needs to be reified anyway)
+ introduce IO::Handle.slurp-rest for slurping rest from handle
+ method 'for' as an alias for 'map'. Map will stop flattening the list eventually, 'for' remains as it is now.
+ method 'unique' as a successor for 'uniq'
+ warn about clashing enum aliases, and also poison these aliases

New in 2014.10
+ unstrict mode now default with -e
+ use strict / no strict implemented (but -Mstrict does not work)
+ Implemented Supply.lines/words
+ Implemented IO::Handle.words
+ Updated chdir() to spec
+ Implemented indir( $dir,:test<r w x>,{...} )
+ Implemented tmpdir($dir) and homedir($dir)
+ Implemented IO::Path.all: "foo".IO.all(<f r w>) is True for r/w file
+ IO::Path.modified|accessed|changed now return Instant, according to spec
+ Fixed ordering issue with IO::Socket::Async
+ Str.words is now lazy by default
+ Str.words no longer returns the word if there is only one word: this behaviour
  was unspecced and apparently used internally only.  This old behaviour is
  still available by specifying the :autoderef named parameter.
+ method .exists/.delete have been removed after 1+ year of deprecation
+ performance improvements in Str.trans and tr///
+ fixed Str.trans and tr/// for anchored regexes
+ Bool.pick/roll (without parameter) now ~20x faster
+ Numeric.round (without parameter) now ~4x faster
+ Supply.more has been deprecated in favour of Supply.emit (as per spec)
+ Deprecations will now tell when they were introduced, and will give a
  release version in which the deprecated feature will be removed.

New in 2014.09
+ ./perl6 --profile for MoarVM, generates HTML profile output, including
  spesh/JIT info
+ Workaround OS X make bug for MoarVM
+ Make new LOLLY syntax the default
+ support for submethod DESTROY (MoarVM only)
+ optimizations to Str.words, Str.lines, IO.lines, chomp, and return
+ Str.lines and IO.lines take :eager for still faster performance
+ added experimental support for Proc::Async, MoarVM only for now
+ Promise.keep/break now default to True/False
+ support for S26-style declarative (#| and #=) comments
+ expectations are reported before result in test failures
+ bare 'say' is now a parse error
+ range *..* is now allowed (and means -Inf..Inf)
+ AST.Str now prints the correct source for operand ASTs
+ 'π' implemented as synonym for 'pi'
+ support for :temp/:let declarators in regexes
+ Reduced memory size of CORE.setting, improved startup time
+ startup (on Moar) 15% faster than p5 w/ Moose
+ fix issue with $*EXECUTABLE pointing to an non-existing interpreter on parrot

New in 2014.08
+ print file/line annotations for warnings also on moar and jvm
+ fixed reduce/infix function syntax [[&foo]] LIST and ITEM [&foo] ITEM
+ can now call exit() in END blocks without hanging or affecting END block execution
+ remove speed penalty of large ranges in character classes
+ make LF, FF, CR and NEL available as character names
+ fixed negated character lookup in regexes \C[...]
+ quote words syntax <a b c> splits on breakable space only
+ duplicates in character classes warn now, like in accidently quoted items <[ '/' ]>
+ fixed (s)printf regression with "+" and " " flags
+ allow a DateTime to smartmatch against a Date
+ fix %a{5}:delete anomaly, "as Str" is your friend
+ die / note now say "Died" / "Noted" when not given anything
+ ∅ is finally recognized as the empty set
+ more work under the hood to get in line with S11 / S22
+ Str.indent() now treats its arg as an Int where appropriate
+ Restructure the QAST classes
+ Add LoL candidates for postcircumfix:<[ ]> and postcircumfix:<{ }>
+ Pass --moar-options configuration to NQP's Configure
+ Add .new candidate for creating a Date from an Instant
+ Fail when a Boolean is used as the matcher for &grep, &grep-index, &first,
  &first-index, &last-index, and the corresponding methods
+ Implement cmp_ok in Test.pm
+ Add HyperWhatever / **
+ Add method invoke as the preferred way to write what was method postcircumfix:<( )>
+ Warn when a Code object is coerced to Str
+ If the LOLLY envar is set, have (;;), [;;], etc., turn into LoLs. Otherwise, parsefail
+ Add SEQ(a; b) to emulate the old behavior of (a; b)
+ Make &infix:<xx> many times faster
+ NaN === NaN (but still NaN != NaN)
+ fix multi-dimensional slice assignment
+ Add .note() method to Mu

New in 2014.07
+ require and build parrot 6.6.0
+ Cool.eval and eval() are now removed
+ assigning a single itemized hash to a hash is now DEPRECATED (my %h = {...})
+ .hash now turns an itemized hash into a hash
+ added unpack directives "a" and "Z"
+ subbuf-rw specced and implemented
+ Supply.zip-latest specced and implemented
+ minute value is optional in Timezone offsets in DateTime.new(), also a colon
  to delimit hours/minutes is now optional
+ file copy and creation operations on the MoarVM now give default file permissions of 0666
+ the tr/// operator is implemented and has the proper return value
+ improved string handling for MoarVM backend
+ fixed class A { my $.x = 42 } scoping on MoarVM
+ removed hack that kept (|)= & co from working
+ re-arranged infixish actions to support [[*]]= etc
+ optimized CompUnitRepo::Local::File
+ optimized takedispatcher to cleardispatcher
+ all backends now allow C pointer arithmetic and casting of pointers to Perl 6 types
  (this functionality is exposed by NativeCall)
+ made block inlining a level 2 optimization
+ small optimizations to number parsing
+ fixed Label.gist
+ fixed 'fail' so it also prints a backtrace
+ fixed a repeat until code-gen bug
+ added CompUnit.name and fixed .perl
+ removed hack for $Inf/$NaN: constants Inf/NaN are exposed since a while
+ made initial/max threads introspectable
+ naive implementation of IO.umask
+ make .WHICH also work on type objects
+ throw a X::Subscript::FromEnd for @foo[-1]
+ throw X::TypeCheck::Binding on all backends (was MoarVM only)

New in 2014.06
+ say/note now a little faster for single Str (which is most common)
+ an initial implementation of S11 (Compilation Units) is now available
+ .IO.{d|s|z} are now about 40% faster and return Failure if path doesn't exist
+ $*DISTRO now works correctly on OS X (with name "macosx")
+ $*KERNEL now works correctly on OS X (with name "darwin")
+ initial implementation of $*USER and $*GROUP
+ initial implementation of Supply.zip-latest
+ implement dummy Lock (for $lock.protect( {...} ) ) on parrot
+ @*INC now only contains elements for actually existing paths
+ more work on allowing slangs transparently (such as "v5")
+ IO::Socket::Async now also works on JVM
+ can close tap to stop listening on a socket
+ implement Supply.on_demand, for making on-demand supplies
+ fix race condition in async socket reading
+ can now also bind to dynamic variables
+ LAST phaser used to fire when not actually iterating, now fixed
+ (Set|Bag|Mix).pairs now return immutable Enums
+ (Set|Bag|Mix)Hash.pairs no longer allow changes feeding back
+ optimize :a(:$b) and attributive binding
+ optimize IO::Path.contents
+ optimize push, unshift, and comb
+ assorted optimizations to Junction construction and dispatch
+ optimize no-args case of @foo>>.bar
+ implement :42nd colonpair syntax
+ include correct version information in perl6-debug

New in 2014.05
+ asynchronous timers on MoarVM backend
+ added or updated many Supply methods:
  act, batch, categorize, Channel, classify, delay, elems, flat, grab, last,
  live, max, min, minmax, merge, migrate, Promise, reduce, reverse, rotor,
  sort, squish, stable, start, uniq, wait, zip
+ add list functionality to 'on', as with new S17 spec
+ added .Supply coercer
+ added IO::Notification.watch_path / IO::Path::watch which return a Supply
  of file system changes
+ added signal() which returns a Supply of Signals (such as SIG_HUP)
+ added IO::Socket::Async.connect, returns a Promise with a IO::Socket::Async
+ added IO::Socket::Async.send, returns a Promise with success / failure
+ added IO::Socket::Async.chars_supply, returns a Supply with chunks
+ added first-index, last-index, grep-index subs/methods
+ Pair.key was erroneously implemented "is rw"
+ added "subtest code, desc" to Test.pm (inspired by P5's Test::More)
+ added "throws_like" to Test.pm (formerly of Test::Util)
+ Test::Tap::tap_ok and throws_like are now 1 test (using subtest)
+ BagHash<foo>-- on non-existing key no longer fails (as per S02 spec change)
+ (Set|Bag|Mix)(|Hash) now have a .fmt method
+ deprecate $*OS, $*OSVER, $*VM<name>, $*VM<config>, $*PERL<name>
  $*PERL<compiler>...
+ added $*KERNEL, $*DISTRO, $*VM, $*PERL as full blown objects
+ .delta (by recent spec change) in Date/DateTime now instead spelled
  .later and .earlier
+ TimeUnit enum removed; string named and positional arguments used instead
+ optimized grep,grep-index,first,first-index,last-index with seperate
  candidates for Regex and Callable.
+ "use v5" is no longer a noop, but actually tries to load the "v5" module
  (soon available as part of Rakudo*)
+ implemented labeled loops and throwing of labels as payload
+ added various optimizations, like optimizing out %_ when unused

New in 2014.04

+ significant performance enhancement for MoarVM, spectest running 20%+ faster
+ S17 (concurrency) now in MoarVM (except timing related features)
+ winner { more @channels { ... } } now works
+ fixed pb with Parcelness of single element array slices with adverbs
+ implemented univals(), .unival and .univals (on MoarVM)
+ make .pick/.roll behave sanely on Enums
+ fixed Str.samespace and ss//
+ added .minpairs/.maxpairs on (Set|Bag|Mix)Hash
+ added Bag.kxxv
+ Capture.WHICH implemented so that identical Captures have the same .WHICH
+ Naive implementation of "is cached" trait on Routines
+ Hash.perl now randomizes key order, while Hash.gist sorts
+ NativeCall passes all its tests on all backends

New in 2014.03

+ Fix suggestions for unknown routines when specified with '&'
+ Match sigil in suggestions for unknown routines depending on specification
+ Improve suggestions for 'length' and 'bytes' being banned in Perl 6
+ fixed for-loops to be properly lazy
+ Zop= now works
+ numerous Pod parsing and formatting improvements
+ uniname, uniprop, and unival implemented on MoarVM backend
+ @<c> as shortcut for @$<c>, %<c> as shortcut for %$<c>
+ improved "unable to deduce sequence" error message
+ duckmap, deepmap implemented
+ list infix reductions no longer flatten
+ X and Z meta ops treat [] as items
+ unary hyper subscripts (@array>>.[0]) now work
+ fixed problem with .=uniq and .=squish

New in 2014.02

+ $*INITTIME implemented
+ improved code generation for loops on the JVM backend
+ eager and lazy statement prefixes
+ statementlist-level for-loops are now assumed to be in sink context
+ improved unspace parsing
+ don't itemize make's ast argument
+ allow definition of custom postcircumfix operators
+ :allow in pod code blocks works now
+ Configure: git protocol is now configurable
+ smartmatching against an IO::Path does the right thing now
+ perl6-debug-* is now installed by rakudo; the user interface is still a
module available from the ecosystem
+ lots of improvements for moarvm, such as client and server socket support
and opening pipes/subprocesses
+ finished NativeCall support on the JVM

New in 2014.01

+ Use .narrow on Numeric to coerce to narrowest Type possible
+ Can now supply blocks with multiple arguments as sequence endpoints
+ <prior> rule no longer exists
+ The eval sub and method are now spelled EVAL
+ Method calls and hash/list access on Nil give Nil
+ No longer need to separate adverbs with comma in argument lists
+ div on parrot will now always round towards -Inf
+ Added support for MoarVM; passes >99% of the spectests that Rakudo JVM does
+ Fixed gather/take stack overflow bug in JVM backend
+ Fixed closure in regex bug on JVM
+ Fixed some line number reporting bugs on JVM
+ Optimized Enum($value) coercion
+ Regexes: Aliased assertions now properly create sub-captures
+ Regexes: Improved detection/reporting of null patterns
+ Implemented IO::Async::File.spurt (JVM only)
+ Implemented Setty.kv and Baggy.kv
+ Use a global ByteClassLoader rather than one per class. (JVM only)
+ Implement more parts of NativeCall for the JVM

New in 2013.12

+ The Whatever Star now works inside chain operators like comparisons
+ Private attributes from roles are now visible in the classes they apply to
+ Use invokedynamic in some places on the JVM.
+ Memory improvements in ListIter
+ Faster method List.combinations
+ Simple lookahead assertions in regexes are optimized
+ Regexes do less superfluous scanning

New in 2013.11

+ Many concurrency primitives harmonized with new S17, but still pretty fluid
+ Refactored build system that allows building rakudo on both backends in the same place
+ Order::Increase/Decrease are deprecated.  Please use Order::Less/More.
+ Leading whitespace is ignored for :sigspace
+ Better null pattern detection in regexes
+ The "gethostname" function implemented
+ Warn when private attributes are a marked rw or readonly
+ "is DEPRECATED" trait now produces report when process finished
+ Parcel.rotate implemented
+ Performance optimization: unfold junctions in 'when' clauses
+ capitalize/.capitalize have been removed, as per docs/deprecations
+ improved run()/shell(), these return Proc::Status-objects now
+ The ... range operator can now be chained: 1,2,3 ... 10,15,20 ... 100
+ various other bug fixes, optimisations and additional tests

New in 2013.10

+ postcircumfix {} and [] are now implemented as multi subs rather than multi methods.  This should allow for better optimization in the future.
+ Add support for "is DEPRECATED", making it easy for early adopters to stay current.
+ Track multiple spec changes for various container classes.
+ Greatly reduce object creation during Regex parsing.
+ Various portability fixes.
+ qx// and run() now auto-quote correctly
+ Allow #`[...]-style comments in regexes
+ unlink() behaves like P5's, it deletes write-protected files on windows

New in 2013.09
+ candidate argument to bless removed (per spec change)
+ @a.VAR.name and %h.VAR.name implemented
+ The $var.++ and $var.() syntaxes work
+ Lots of improvements on the Set and Bag types
+ [op]() with relational operators vacuously return True
+ tr/// implemented
+ Sockets on JVM implemented
+ sleep(), sleep-time() and sleep-till() updated to spec

New in 2013.08
+ "is default" traits on variables, $/, $!, $_ are default Nil
+ "is dynamic" traits on variables, $/, $!, $_ are dynamic
+ "of TypeObject" trait on variables
+ .VAR.default/dynamic/of return the state of these traits
+ Assigning Nil, calling undefine() restores the default value
+ .WHAT more accurately returns a type object for specifically typed cases
+ Option --gen-nqp for ConfigureJVM.pl
+ Include file name in parser errors
+ Parse labels, tr/// (both don't do anything useful under the hood yet)
+ CALLER::<$var> now only works on dynamic variables, as per spec.
+ Improvements to Threads, including Channel and KeyReducer (JVM only)
+ Asynchronous file reading (JVM only)
+ Improved JVM interop, including 'use :from<java>' (JVM only)
+ Fixed subroutine inlining on JVM
+ Fixed %*CUSTOM_LIB on JVM
* Fixed sink context handling on JVM
+ Reimplementation of Buf as a role
+ Implemented Blob role
+ Implemented sized/encoded Buf/Blob types (buf8, blob8, utf8, etc.)
+ Str.encode now returns most specific appropriate type
+ "once" phaser fully implemented
+ Named parameters "with" and "as" on uniq/squish
+ "samewith()" for calling method on same dispatcher again
+ "will" variable trait partially implemented ($_ not set yet)
+ Interpolating strings into heredocs now dedents properly
+ Solved a slowdown when declaring custom operators
+ Improved P5-regexes (backslash sequences, code blocks)
+ Make type objects appear as Nil in non-scalar contexts
+ Placeholder variables $^A .. $^Z no longer allowed, as per spec
+ printf %d now supports bigints also on Parrot
+ my and our scoped methods no longer go into the method table
+ Implemented keybag(), KeyBag.push, KeyBag.categorize
+ Re-implemented hash iteration for a performance win
+ Various optimizations, code cleanups and error message enhancements

New in 2013.07
+ Huge progress in JVM backend (feature-wise almost on par with Parrot)
+ List.first is now lazy
+ unspace before argument lists is now supported
+ fixed handling of indented heredocs
+ basic support for threads and promises (JVM only)
+ improved sprintf and other formatting routines
+ keyof method for typed hashes to get key type
+ Hash.perl nows works for typed hashes
+ 'is parcel' and 'is default' traits (work in progress)
+ Parcel.new now works
+ slight optimization to join of many items
+ implemented canonpath for Win32 IO::Spec
+ implemented squish
+ made []:(kv|p|k|v) work according to spec
+ properly parse Pod formatting codes with brackets other than <...>
+ the POD_TO_TEXT_ANSI environment variable now leads to some formatting
  being applied by Pod::To::Text
+ declaration of multiple operators in a scope now generates much smaller
  serialized output
+ Int.round method now takes a scale argument
+ implemented Complex.ceiling, Complex.floor, Complex.round

New in 2013.06
+ JVM backend added - passes initial sanity tests
+ type captures in signature binder implemented
+ IO::Spec::Unix.canonpath made more efficient
+ IO::Handle methods gist, perl, path added
+ Int.msb and Int.lsb implemented
+ dir() is now lazy
+ lines($limit) now doesn't read an extra line
+ .^mro methods added to a few role metaclasses
+ $/ and $! now visible in eval/REPL
+ IO::Handle.copy moved to IO::Path.copy
+ .{} adverb combinations all implemented
+ :$<foo> colonpair syntax implemented
+ 'my &foo; multi foo() { }' gives better error message
+ reduce() more aware of fiddliness
+ &first now returns Nil instead of failing
+ $*CWD and $*TMPDIR now contain IO::Path objects
+ REPL bug fixed when same line issued twice
+ pick/pop/push/roll/reverse/rotate/sort/classify/categorize
  now fail immediately if the list is infinite
+ categorize now returns a Hash, not a Parcel of Pairs
+ "undef" warning now refers to Any, not Mu
+ improved error messages for hash shapes
+ Hash.(classify|categorize) implemented
+ IO::Path.chmod implemented
+ IO::Path.succ and .pred implemented
+ syntax parser now allows a dot before hyper postfix
+ Str.succ added for codepoints \x2581..\x2588
+ Cool.path implemented
+ sequences between 1-codepoint strings implemented
+ div and / fail with X::Numeric::DivisionByZero (rather than dying)
+ doing .perl on Rat with denominator 0 doesn't go into an infinite loop anymore
+ Capture.exists implemented

New in 2013.05
+ IO::Spec, a port of Perl 5's File::Spec
+ support for exporting things form EXPORT subroutine
+ ?-quantifier in regexes doesn't create arrays in the Match object anymore
+ speedup of repeated shifts of large lists and arrays by 70%+
+ implemented Cool.lines
+ renamed IO to IO::Handle; IO is now a tag role, as per spec
+ simplify timezone handling
+ .Set and .Bag methods for List and Parcel
+ regex special characters can be used as delimiters
+ allow slice with :exists adverb on hashes …
+ .hash now accepts optional :type and :of named parameters
+ Make :exists and :delete up to spec …
+ fix for autoviv Typed hash problem
+ constant-fold infix:<~>
+ make decl and init of our-scoped arrays/hashes work
+ fix regex interpolation slowdown
+ fix exporting of subroutines
+ fix slurpy is-rw array-parameters
+ failed regex matches return Nil
+ add support for IO::Path::<os subclasses>
+ fix reporting of errors in gather/take.
+ added 125 extra opening/closing bracket-pairs
+ fix build failure on SPARC and PowerPC
+ underlying nqp layer supports parrot and JVM as backend, in preparation
  for JVM support in a future Rakudo release
> more than 100 not listed changes

New in 2013.04
+ add Capture.Bool()
+ optimize getting size of numeric Range
+ for loops are eager again
+ improvements to DUMP()
+ wrap NQP objects in ForeignCode, allowing perl6 OO calls on them
+ improve some messages on parsefail.
+ add link and symlink to IO
+ reduce compile-time autothreading to avoid issues with !==
+ improve optimizer - caching, constants
+ fix List.ACCEPTS() for Whatever special case
+ bring 'require'  closer to spec, esp. by taking paths
+ bring 'IO::Path' closer to spec
+ remove parrot dynops already provided as nqp ops
+ translate a dynop to nqp code
+ update from pir:: calls to nqp::

New in 2013.03
+ Type names now gist as (Any) rather than Any()
+ Warn when pure expressions are used in sink context
+ Cool.substr(...) now correctly accepts whatever-star closures
+ Fix character class subtraction bugs
+ Correctly detect undeclared variables in regex assertions
+ :i now respected in character classes
+ Improved output of Rat.perl
+ Implemented shellwords postcircumfix (%h<< $x 'foo bar' >>)
+ User-defined circumfixes now parse a semilist rather than just an expression
  and handle whitespace correctly
+ Forbid null operators
+ Warn about leading 0 not indicating octal in Perl 6
+ Fix some automatic end of statement on "}" parse bugs
+ Better error message on for(...) {} being interpreted as a function call
+ Array interpolations now properly do LTM
+ Respect :i in constructs like /:i <$var>/
+ Autothread "none" and "all" junctions before "any" and "one"
+ Helpful error if you write "else if"/"elif" instead of "elsif"
+ Throw exception if a Range is used as a Range endpoint
+ Corrected argument order in IO.seek
+ Multi-dispatch now mostly implemented in NQP, not C
+ Fixed LEAVE (and thus UNDO/KEEP/temp) not firing in multis or upon 'next'
  in a for loop

New in 2013.02
+ "Did you mean ..." suggestions for symbol-not-found errors
+ Compile-time optimization of some cases of junctions in boolean context
+ Date and DateTime now support a .delta method
+ IO::Socket.get now works again with non-Unicode characters
+ $() now takes $/.ast into account
+ proper return value for smartmatching against a substitution
+ better error reporting when a parent class does not exist
+ constant folding for routines marked as 'is pure'
+ natively typed variables now work in the REPL
+ better error reporting in the REPL
+ writable $_ in -p and -e one-liner
+ speed up eqv-comparison of Bufs
+ warnings for useless use of (some) literals, variables and constant
  expressions in sink context
+ /../ and rx/.../ literals match against $_ in sink context
+ array variable interpolation into regexes

New in 2013.01
+ sink context; for-loops are now lazy by default
+ first mentioning a variable from outer scope and then redeclaring it
  in the same scope (my $a; { $a; my $a }) is now an error.
+ the long-deprecated "SAFE" setting has been removed
+ 'require' now works with indirect module names
+ restored socket read semantics to returning the requested number of bytes
+ $obj.Some::Role::meth() now passes the correct $obj
+ try/CATCH now returns Nil when the CATCH is triggered, rather than the
  exception; this brings it in line with try without a CATCH
+ whatever-star cases of splice now implemented
+ sequences with Junction endpoints now work
+ corrected precedence of various set operators
+ fixed binding of non-Any things into hashes and arrays
+ can now import multis with the same name from different modules,
  provided all dispatchers are onlystar

New in 2012.12
+ ~/.perl6/lib is gone from the default include path
+ fixed indent method's handling of empty lines
+ fixed .indent(*)
+ parse errors now formatted like in STD, with color
+ location of parse error now indicated with context
+ highwater algorithm implemented, greatly improving accuracy of parse error
  line numbers and locations in a range of cases
+ some parse errors now report what the parser was looking for at the time the
  parse failed
+ better errors for unmatched closing brackets and two terms in a row
+ uniq now has === semantics as specified, not eq semantics
+ junction auto-threader optimized and is an order of magnitude faster
+ implemented sub term:<foo>
+ implemented texas versions of the Set and Bag operators
+ good error for use of . to concatenate strings
+ flattening large lists of Parcels now happens in about half the time
+ adopted STD panic/sorry/worry model, meaning that we now keep parsing
  further and can report multiple issues in a range of cases
+ we now catch and complain about post-declared type names
+ variable redeclarations are now just a warning, not an error
+ a mention of an &foo that is never defined is now an error
+ fixed .perl output for a Pair with a Pair key
+ interpolation of undeclared arrays, hashes and functions now detected
+ { a => $_ } now correctly considered a block, not a hash as before

New in 2012.11
+ user-defined operators only affect the parser in the scope they are declared in
+ fixed pre-compilation of modules containing user-defined operators
+ implemented precedence related traits (equiv, looser, tighter, assoc)
+ Perl 6 grammar NFAs are pre-computed, saving some work on each invocation; this
  shaved around 10% off the time needed to run the spectests
+ redeclaring a class as a role now gives a better error
+ the < foo bar > syntax in regexes now respects :i
+ << ... >> now interpolates, respecting quoting and pairs
+ fix error reporting for not-found dynamic variables
+ many protos now have much narrower signatures
+ quote parsing implementation aligned with the approach STD uses
+ regexes and quotes have better support for user-selected delimiters
+ quote adverbs
+ heredocs
+ carry out IO::Path.dir deprecation
+ implement infix:<andthen>
+ macro arguments now carry their lexical environment properly
+ postfix operators of the form '.FOO' take precedence over method calls
+ version control markers detected and gracefully complained over
+ INIT phasers now work as r-values
+ our ($x, $y) style declarations fixed
+ take and take-rw now evaluate to the taken value
+ implemented cando method on Routine
+ FIRST/NEXT/LAST can now be used in all types of loop (previously limited to for)
+ implemented operator adverbs
+ implemented :exists and :delete subscript adverbs and on hashes
+ implemented :p, :k, :v and :kv subscript adverbs on arrays and hashes
+ fixed shell words post-processing like << foo "bar $baz" >>
+ byte-order mark at the beginning of a file is now ignored
+ fixed bug that could lead to disappearing symbols when loading pre-compiled modules
+ Configure no longer passes --optimize to Parrot if --parrot-option is specified
+ deprecated current &foo semantics
+ fixed #`foo and friends at start of statementlist
+ simplify setting line number of compile-time exceptions
+ made :($a, $b) := \(1, 2) update $a and $b

New in 2012.10
+ :60[24, 59, 59] radix form
+ delegation to methods using the handles trait
+ fixed serialization of Buf
+ improved handling of :P5 regexes (more features, less bugs)
+ determining that an object lacks a method is usually now much faster
+ reduced memory usage of Match objects and optimized their construction a little
+ some code-generation improvements related to void context
+ implemented :dba('...') modifier in regexes
+ various error messages improved through use of :dba('...') in the Perl 6 grammar
+ implemented 'x' in pack
+ added $*CUSTOM-LIB
+ eval in a method can now see self, attributes and $?PACKAGE
+ each REPL line no longer implies a fresh GLOBAL
+ fixed some Pod parsing issues with Windows newlines
+ fixed interaction of :i and LTM (alternations and protoregexes now respect it)
+ import of custom meta-objects only affects the scope they are imported into
+ made <-> lambdas work
+ can now parse nested pairs of quote delimeters, like q{ foo q{ bar } baz }

New in 2012.09.1
+ is-prime and expmod
+ smart matching against Signature literals
+ binding to signatures in declarators
+ the is hidden and base traits
+ ability to set encoding on sockets temporarily removed (reverts to 2012.08 behavior)

New in 2012.09
+ class Iterable does not inherit from class Cool anymore
+ basic macro unquoting
+ basic support for m:P5/.../ regexes
+ support for indirect type names in routine and type declarations
+ compiler now built with QAST-based NQP, which generates better code, thus
  making the compiler a little faster
+ support for "is export" traits on constants
+ implemented Str.wordcase
+ can now write more complex proto subs and methods, using {*} to enter the
  dispatcher
+ tie-breaking with constraints now picks the first matching one rather than
  demanding they be mutually exclusive

New in 2012.08
+ tclc implemented
+ --> ReturnType in signatures and prefix type constraints of routine return
  types are honored
+ reduced memory usage at build time by around 35% - 40%
+ the argument to IO::Socket.recv is now interpreted as a number of characters
+ enum lists and arguments to parametric roles are now evaluated at compile time
+ switched to new internal AST and backend representations (QAST and PIRT)
+ removed deprecated routines Str.bytes and Str.lcfirst/&lcfirst
+ errors from traits now contain file name and line number
+ IO::File and IO::Dir have been removed
+ inliner has been improved and can inline a wider range of routines
+ simple implementation of the 'soft' pragma
+ fixed over-eager treatment of numeric literals as int rather than Int in cases
  where they appeared each side of an infix operator
+ detect circularities in module loading
+ sigilless variables in signatures when proeceed by | or \
+ prevented blocks that declare variables turning into hash constructors
+ made pre-compilation complain if dependencies are not pre-compiled yet
+ fixed interpolation of double-quoted strings in regexes
+ fixed issue with Num.new not being friendly to subclassing
+ implemented handling of complex numbers in Str.Numeric

New in 2012.07
+ Deprecated SAFE.setting in favor of RESTRICTED.setting
+ Ranges can now interpolate in argument lists
+ The built-in meta-objects (such as Metamodel::ClassHOW) now inherit from Any
+ &open now supports :enc/:encoding
+ Exception.fail, .resumable and .resume
+ Changed &dir to return IO::Path objects, not strings
+ Deprecated .bytes, .ucfirst, and .lcfirst
+ &slurp now supports :bin
+ &spurt implemented
+ cleaned up Version implementation
+ fixed :s file test
+ recognize obosolete rand() and rand(N) forms at compile time
+ anonymous subset types 'subset :: of Int where { $_ > 0 }'

New in 2012.06
+ Rakudo is now compiled with the same regex engine as user-space regexes use
+ transitive longest-token matching in protoregexes
+ changed the output of Match.gist
+ string to number conversion now fails for non-numbers
+ string to number conversion now recognizes radix notation
+ string incrementation is now aware of more scripts
+ <|w> word boundary in regexes implemented
+ more errors from within the meta model now contain line number and file name
+ &push and &unshift functions can now autovivify
+ user-defined operators properly participate in LTM
+ Rakudo's C code is now compiled with optimization switches turned on
+ basic module loading tracing with the RAKUDO_MODULE_DEBUG=1 env variable
+ longest token matching with alternations
+ require with argument list
+ compile time errors in loaded modules now show a module loading backtrace
+ improved list and .map handling
+ can now use | to flatten a pair into an argument list as a named argument

New in 2012.05
+ meta ops //=, ||= and &&= now short-circuit properly
+ Failure objects don't blow up the REPL anymore
+ allow case insensitive regex matches without ICU in limited cases
+ %*ENV now propagates into subprocesses
+ RAKUDOLIB env variable supported in addition to PERL6LIB
+ -I and -M command line options
+ $?LINE and $?FILE variables
+ warnings now include line number from program, not from CORE.setting
+ reduction meta-operator on list-associative ops now has correct semantics
+ now have :th alias for :nth in Str.match
+ import collisions now report the name of the module that is to blame
+ ms// fixed
+ <$x> in regexes caches the compiled regex, which can be a big performance win
+ implemented temp and let
+ 'use' can now import by tag name
+ 'use' with positional arguments
+ lib.pm
+ updated calling conventions for traits
+ implemented fff flip-flop operator; improvements to ff form also
+ removed current directory from default library search path
+ 'import' works
+ symbols installed in EXPORT in all nested packages, not just UNIT::EXPORT
+ enumeration types can be used as roles
+ END phasers now run when program ends with exit or an exception
+ fix Rat.floor and .ceiling to work for large numbers
+ improved Rat stringification
+ Real is now a role, as it should be
+ implemented < foo bar baz > syntax for alternations in regexes
+ implemented <( and )> syntax for setting from/to of match  in regexes
+ support for non-Int enums
+ basic support for Version literals
+ chmod now available as a function
+ roundrobin implemented
+ fixed a bug in precompilation of modules that use roles from other modules
+ basic implementation of pack and unpack
+ implemented substr-rw, which provides an l-value (assignable) substring
+ implemented <~~> (recursive call into self) syntax in regexes
+ 'LAZY' statement prefix

New in 2012.04.1
+ autvivification for arrays and hashes
+ more robust module precompilation
+ improved infrastructure for calling C code
+ $.foo style calls now contextualize correctly
+ &infix:<cmp> now return members of the Order enum in all cases
+ --doc=format now loads Pod::To::format and uses it for rendering
+ 'lib/' is no longer in the default include path
+ improved Parameter.perl
+ add .changed, .modified and .accessed methods to IO
+ improved --help output
+ install precompiled test module for speedup
+ fixed printing of backtraces when regexes are in the call chain
+ case insensitive regex matches now also work for interpolated variables

New in 2012.04
+ 'defined' is now a listop instead of a prefix op
+ fixed :16('0d...')
+ implemented simple interpolation in names in type declarations (class ::(const) { })
+ $=POD renamed to $=pod
+ fixed slicing of non-lists with infinite ranges
+ fixed accidental over-serialization, cutting ~300KB off each pre-compiled module
+ scalar positionals no longer treated as slices
+ implemented Routine.package
+ join will now always reify at least 4 elements of a list if possible
+ warnings now have line numbers
+ brought back Str.indent
+ ban declaring pseudo-packages, with a helpful error
+ a name followed by :: now returns .WHO, so Foo::<&bar> style lookups work
+ Exception.Bool now returns true
+ avoided re-parsing of longname, which speeds up the parse a bit overall
+ implemented MY, CALLER, OUTER, UNIT, CORE, SETTING and DYNAMIC pseudo-packages
+ implemented ::<$x> and ::{'$x'} style lookups
+ some small optimizations to various Str built-ins and MapIter
+ improved --doc output
+ added $*PERL
+ implemented IO::ArgFiles.slurp

New in 2012.03
+ updated to dyncall 0.7
+ infix:<eqv> now autothreads over junctions
+ more typed exceptions
+ pre-compiled modules/settings are now serialized, not re-built on load
+ startup time is now about 25% of what it once was
+ significant memory and time reduction (~40%) when pre-compiling modules/settings
+ BEGIN and CHECK now work in r-value context
+ constant declarator now works with non-literals on the RHS
+ implemented Set, Bag, KeySet and KeyBag types
+ implemented :exhaustive and :nth match adverbs
+ implemented ENTER, LEAVE, KEEP and UNDO phasers
+ implemented FIRST, NEXT and LAST phasers in for loops
+ implemented START phaser, including use of it in r-value context
+ implemented also syntax for adding traits inside a block/package
+ implemented macro declarations and quasi quotes (sans placeholders)
+ implemented anonymous enums
+ 'our multi' now dies (used to ignore the 'our')
+ implemented PRE and POST phasers
+ ~25% performance improvement to array indexing

New in 2012.02
+ catch duplicate accessor generation required of "has $.x; has @.x;"
+ many more typed exceptions thrown
+ undeclared attributes mentioned in signatures now caught at compile time
+ empty Buf is now False in boolean context
+ implemented <prior>
+ implemented /<Foo::Bar::baz>/ syntax
+ /<x>/ can call a predeclared lexical regex x
+ conjugate is now called conj
+ enumeration values .gist to just the key, not the full name
+ <!> in regexes fixed
+ implemented Match.make(...) method
+ better error reporting for improper use of nextsame and friends
+ initializers now parsed as part of a variable declarator
+ trailing whitespace now removed from Pod declarator blocks
+ List.tree made more useful
+ implemented rename and copy functions
+ ().pick and ().roll now return Nil
+ default MAIN usage message includes .WHY of the candidates
+ X::Base eliminated in favor of Exception
+ various range iteration fixes; Num ranges now produce Num lists
+ LHS of the xx operator is now thunked
+ can now declare state/constant/our in regexes (before, only :my worked)
+ improved backtraces
+ catch constructs that require an invocant but don't have one
+ catch uses of virtual method calls in submethods and attribute initializers
+ improved parsing and performance of reduction meta operators
+ Rat arithmetic now properly defaults to Num if the denominator is too big
+ FatRat implemented
+ implemented long forms of regex adverbs (e.g. "ignorecase" maps to "i")
+ fixed "but True" and "but False"
+ object hashes, with the my %h{SomeObjectType} syntax
+ implemented Int($x) style coercions
+ implemented Capture.perl

New in 2012.01
+ -c command line option re-implemented
+ take flattening bug fixed
+ duplicate named parameter names detected
+ fixed clone being too shallow with regard to containers
+ fixed negative modulo for bigint
+ better Routine.perl
+ .DEFINITE macro implemented
+ .^methods, .^attributes and .^parents now support :excl (the new default) and :all
+ Array.delete implemented
+ restored basic -n and -p functionality
+ improved parameter introspection
+ fixed operations on bigints when the first operand had been mixed in to
+ fixed multi-dispatch narrowness calculation for native types
+ binding to array and hash elements
+ added Order enumeration, and updated cmp and <=> to use it
+ adding various missing magicals, such as &?ROUTINE and ::?ROLE
+ accessor generation for my $.x and our $.x cases
+ fixed @x>>.() (hyper-invocation)
+ updated Complex.Str to match current spec
+ fixed eval to see GLOBAL properly
+ implemented 0 but Answer(42) style mix-ins
+ fixed various issues in scoping/handling of $/
+ fixed usage of make in a regex (previously, only worked in action methods)
+ optimized Range.roll and Range.pick for large ranges
+ fixed non-numeric, no-Str ranges
+ fixed build on Cygwin
+ fixed regex backtracking into subrules and captures

New in 2011.12
+ improved protoregex support, including NFA caching
+ <before ...> and <after ...> (lookahead and lookbehind)
+ backslash sequences in character classes
+ fixed quantified captures and :r interaction bug
+ optimized match object construction, ListIter, substr and chomp
+ improved performance of send/get on sockets
+ optimizer detects missing private methods and simplifies calls (level 3 only)
+ fixed some issues when an array was assigned to itself, maybe using .=
+ implemented .wrap and .unwrap, plus wrap handles with a .restore method
+ implemented .trans on strings
+ unicode properties can be matched against in regexes
+ binding to @, % and & sigils now checks for the appropriate role
+ assignments to variables declared with the & sigil now checked for Callable
+ typed hashes, partial support for typed arrays
+ some parametric role fixes
+ can now use but operator with a type object
+ smartmatching of regexes against arrays and hashes
+ socket IO now implements .write and custom input line separators
+ implemented getc
+ implemented .WALK
+ implemented ff, ^ff, ff^ and ^ff^
+ implemented .REPR macro
+ implemented Proxy class
+ some typed errors are now thrown from within the compiler
+ stubbed methods from roles now require those methods to be implemented
+ updated docs/ROADMAP
+ .WHICH now returns ObjAt objects
+ defining new operators

New in 2011.11
+ CATCH blocks are now much closer to spec
+ big integer support
+ basic protoregex support with NFA-driven LTM for some declarative constructs
+ correct default values for natively typed variables
+ fixed initialization of state variables
+ improved support for natively typed variables
+ catch more uses of undeclared variables
+ splice() is now implemented
+ uniq() is now implemented
+ several runtime errors now throw properly typed error objects
+ various performance improvements, for example to the X meta op and Str.succ
+ improved support for MAIN argument parsing
+ fixed lexicals/recursion bug
+ IO.copy is now implemented

New in 2011.10
+ operators and functions with native type arguments
+ detection of call to undefined routines at CHECK time
+ various optimizations: inlining of operators, CHECK time dispatch decisions
+ performance improvements of MapIter
+ support @$foo style derefencing/coercion
+ Exception.backtrace
+ eval() has stopped to catch exceptions

New in 2011.09
+ Rewritten meta object protocol and object storage
+ many speedups
+ Int, Num and Str are now far more lightweight
+ much more robust handling of infinite list
+ basic LoL (List of Lists) support
+ :U and :D type modifiers
+ protos and multis now conform to the new spec
+ improved enum support
+ basic 'constant' declarator
+ .WHAT and friends as macros
+ chrs sub and method
+ support for .gist
+ run() has been renamed to shell() to conform to current spec
+ hyper methods now descend into nested data structures
+ basic safe mode (through --seting=SAFE)
+ recording and reporting of test timings (tools/test_summary.pl)
+ Pod parsing and --pod=text option
+ basic support for .WHY
+ greatly improved BEGIN-time support
+ traits applied at BEGIN time for packages, routines and attributes
+ parametric roles reify types properly, fixing many bugs
+ better handling of type variables
+ support $?CLASS, which is generic in roles
+ support import/export of custom meta-objects for built in package declarators
+ custom meta-objects can override method dispatch
+ faster, allocation-free multi-dispatch cache
+ a custom BUILD does not suppress default values
+ undeclared attributes detected and reported at compile time
+ basic support for native int/num types on lexical variables
+ int/num as attributes are stored compactly in the object body

New in 2011.07
+ fractional powers of negative numbers now result in Complex numbers
+ obtain spectests from a specific branch of the 'roast' repo
+ fix bug that prevented build on systems with little RAM

New in 2011.06
+ added take-rw built-in
+ numerous build system improvements
+ assignment now evaluates arguments right-to-left

New in 2011.05 release
+ added a call counter for builtins in Perl 6-level subroutines
+ gcd (greatest common divisor) and lcm (largest common multiple) operators
+ build system improvements
+ added --ignore-parrot-rev option to Configure.pl
+ Configure.pl now creates "config.status" file
+ fixed relational operators when used with NaN
+ implemented Int.base
+ speedup smart-matching against numbers and Str.comb with default arguments
+ added RAKUDO_SUBLOG environment var for tracking subroutine calls
+ overall performance speedups

New in 2011.04 release
+ implemented Str.indent
+ A new, much simpler API and implemention of IO::Socket::INET
+ Unified error messages to use "Cannot"

New in 2011.03 release
+ improved error message on type check failure in assignment
+ -n and -p command line options
+ Test.pm's skip() now has argument ordering consistent with todo()
+ implemented complex conjugation
+ more IO methods related to stat

New in 2011.02 release
+ IPv6 support
+ more robust numeric exponentation
+ --ll-backtrace command line option for PIR level stack traces
+ future-proof for upcoming generational garbage collector in parrot
+ various constructs now return Nil
+ infix:<orelse> implemented
+ infix:<^^> and infix:<xor> improved
+ negation metaoperator is now restricted to operators that return Bool

New in 2011.01 release
+ faster subroutine calls (type cache)
+ 'handles RoleName' now works
+ Test.pm: s/done_testing/done/
+ non-spec debugging pragma Devel::Trace
+ improved parsing of keyword boundaries
+ sped up .comb

New in 2010.12 release
+ new .trans algorithm
+ fixed $*PID on MacOS X
+ don't register names of anon types
+ configuration improvements
+ updated Any functions
+ fix $*IN_DECL leakage
+ implemented Hash.hash
+ Temporal updates
+ Buf.decode fixed
+ open() fixed for binary flag

New in 2010.11 release
+ now works with parrot on git
+ implemented qw//
+ 5x speedup of .trans
+ various improvements to Set
+ don't use deprecated charset ops anymore
+ Bool.Bool and Bool.so now return False
+ implemented &elems
+ improved error for Date.new(Str)
+ improvement on hyperoperators
+ indexings like .[0 .. *-1] work now

New in 2010.10 release
+ True and False now stringify according to the specification
+ basic form of 'require' for run time module loading
+ warnings from the setting now produce line numbers in the users' program
+ local time zone available as $*TZ
+ more consistent line numbers from warnings
+ getting and setting attributes via introspection
+ implement samespace, ms// and ss///
+ hyper operator invoving = can now modify their arguments
+ speed up Str.flip by over a factor of 100

New in 2010.09 release
+ new methods on IO concerning the modify and access time of files
+ S32::Temporal now completely implemented
+ Instants and Durations
+ speedup for slurp() and .reverse built-ins
+ various improvements to the Set type
+ revamp of series operator code, and adaption to new spec
+ implement ...^ up-to-but-excluding-series operator
+ allow :r and :ratchet modifiers on regex quoting constructs
+ Bool.pick
+ significantly improved enum implementation

New in 2010.08 release
+ syntactic adverbs on substitutions, rx quotes and m//, e.g. '$x ~~ s:2nd/a/b/'
+ updated ROADMAP
+ speedups for integer operations
+ the Match class's .perl method now produces useful, roundtrippable Perl code
+ the MAIN subroutine can now parse short arguments
+ the cmp and <=> operators now work on more numeric types
+ the Buf class now has .pack and .unpack methods with partial functionality
+ numeric bitshift operators now have the correct precedence
+ smartmatch against True or False is now an error

New in 2010.07 release
+ support for delegation via 'handles'
+ implemented binding with := and read-only binding with ::=
+ implement OS related built-ins like mkdir, cwd
+ improved diagnostics in Test.pm
+ basic binary IO, buffer encoding and decoding
+ magic $*ARGFILE file handle
+ more robust closures
+ multi-level Array and Hash element autovivification
+ perl6 --version now identifies the exact git sha1 and parrot version
+ implemented 'is rw' trait on classes
+ file tests now work through IO, ie.  'README'.IO ~~ :e
+ generic, multi-level Whatever-currying (eg grep !(* % 2), @list)
+ improved error reporting in many cases, especially multi-method dispatch
+ implemented backtracking into capturing groups and subrules
+ phasers refactored, they can now return results and see the setting
+ custom circumfix operators
+ basic .wrap and .unwrap implementation
+ weighted Hash.pick
+ .perl on custom classes now dumps attributes
+ Basic implementation of the ==> and <== feed operators
+ Int ~~ Num is no longer true, as per spec; use Numeric instead
+ Improvements to enumerations

New in 2010.06 release
+ new list model with immutable iterators, lots of fixes to lists and arrays
+ variable interpolation into regexes
+ compile time Whatever currying for infix, prefix and postfix operators
+ autoprinting in the REPL shell
+ in @*INC, the current directory '.' now comes at the end, as in Perl 5
+ basic Buf implementation: Str.encode/Buf.decode work for UTF-8
+ proper Perl 6 match objects
+ Backtraces with Perl 6 subroutine names and line numbers
+ MAIN and USAGE subs
+ basic version of Str.trans
+ mix-ins with non-roles (5 but 'string')
+ @*ARGS is now read-write
+ IO::Socket::INET again works in CORE
+ hash and array slices have been greatly improved
+ basic support for callframe() and CallFrame type

New in 2010.05 release
+ implemented lexical and anonymous classes and roles
+ manual pages are now installed
+ the .match method now understand the adverbs :c; :p, :nth, :x, :g, :ov
+ test reports with tools/test_summary.pl now record detailed timing information
+ many improvements to numeric handling
+ implemented S (sequential) meta operator
+ fixed placeholder parameters ($^a, $^b)
+ basic enum implementation
+ implemented List.classify
+ turned on an additional 47 test files
+ further improved error messages
+ implement zero-argument versions of many binary operators
+ basic interoperation with Perl 5 through the external Blizkost project

New in 2010.04 release
+ interpolation of expression ending in postcircumfixes into double-quoted
  strings (for example "cards: @cards.sort()")
+ prefix and postfix hyper operators
+ multi subs now work properly when lexically scoped
+ implemented item assignment with tighter precedence than the comma operator
+ loading of .pm6 modules
+ Basic implementation of Numeric and Real roles
+ implementation of DateTime and Date built-in types
+ named regexes can be declared outside of grammars again
+ support for numbers with arbitrary radix, including fractional numbers (:16<DEAD.BEEF>)
+ implemented fmt(), printf() note() and IO.getc built-in routines
+ infix meta operators now inherit the precedence of the modified operator
+ &[+] short name for infix operators
+ hash slices
+ signature literals
+ smart-matching against signatures
+ more consistent implementation of prefix:<|> for interpolating things into
  signatures
+ better error message on accidental usa of Perl 5 features such as << as
  bit shift operators, and catch many perl 5 magic variables
+ implemented type Cool
+ implemented anonymous classes and roles
+ implemented $*PID
+ method introspection works again
+ better error message for calling non-existent routine in a namespace
+ now run programs with the setting as an outer lexical scope, as per spec

New in 2010.03 release
+ The trigonometric functions and the Rat class have received numerous
  updates, making them faster and more complete
+ .^parent now works again
+ The invocation logic has received various speedups
+ Hash creation has been optimized
+ Various improvement related to constant internal strings have led to
  slight speedups
+ .pick, .sort, .keys, .values, .kv, sprintf were reimplemented, ported
  from the old 'alpha' branch
+ The statement modifier for loop works again
+ Various parsing bugs have been sorted out; one having to do with
  closing curly braces at the end of a line not terminating the statement
+ .CREATE, .BUILDALL and .can in the OO system have received attention,
  some of it leading to mild speedups
+ $*PROGRAM_NAME and @*ARGS now work
+ Deferral works again (nextsame/nextwith/callsame/callwith)
+ Array.delete works again
+ Fixed .?, .+ and .* along with matching latest spec on .?
+ Switch untyped variables to default to Any instead of Mu
+ &foo lookup syntax works again (including for operators)
+ Various cases of eqv operator implemented
+ Make overriding postcircumfix:<( )> work again, this time per spec
+ Make junctions of code objects invokable again
+ Lazy implementation of the Z operator
+ Added back @*INC
+ Read-only %*ENV support
+ Grammars work again
+ Implemented regexes taking parameters
+ Implemented proto-regex declarations
+ Initial work on getting subset types working again
+ Add back many of the file test methods
+ Added docs/S11-Modules-proposal.pod documenting how we intend to handle
  modules through Rakudo *
+ First cut of locating and loading modules with a given version and/or
  authority, and in absence of a requirement selection of the latest
  version by default if multiple are available.
+ Many improvements to the series operator
+ Implemented 'need' and a first cut of 'import'; 'use' works in terms
  of them
+ Import is now into the lexical scope by default, as per spec
+ Removed requirement to hand-pre-compile .pm to .pir for use with 'use'
+ Improved multi-dispatch candidate not found errors to include details of
  the available candidates
+ Implemented 'use MONKEY_TYPING'
+ Many cases of smart-match work again
+ $x.Foo::bar() and $x.$y() work again
+ $.foo(1,2,3) works again
+ !, R, X and Z meta-operators work, albeit with some caveats
+ s/foo/bar/ and s[foo] = 'bar' substitution syntax implemented
+ Array.rotate added back
+ User defined operators (prefix, postfix, infix) working again
+ Many more small but important improvements to built-in types and functions
+ Various other bug fixes
+ ROADMAP updates

New in 2010.02 release
+ The branch formerly known as 'ng' becomes the new master branch
+ The previous master branch is now Rakudo/alpha
+ NQP-RX replaces NQP in the Parrot Compiler Toolkit, enabling the
  source code of the compiler to be written in a subset of Perl 6 that
  is much more powerful, most importantly with regexes, as the name
  suggests
+ The revised Perl6/Grammar.pm is much closer to the canonical STD.pm
+ Regexes may declare contextual and lexical variables
+ Lazy lists and arrays are partly implemented
+ The object metamodel is largely written in NQP-RX instead of PIR
+ The name of the root of the object hierarchy is now Mu
+ The term 'undef' is gone, replaced by Nil, Mu or *.notdef depending on
  context
+ Builtin classes derive from Cool which derives from Any
+ The refactored source code is more compact and more easily extended
+ The number of spectests passed has reduced from a peak of 32731 in
  alpha to 24221, because porting the functionality to the new master
  is still ongoing
+ Release numbering changes from 'dash' to 'dot' delimiter to get on
  better with various package management systems

New in 2010-01 release
+ Added method form of eval.
+ Implemented :s and :l file operators
+ Added functions for logarithms using $base
+ Refactored subroutine calls to use new Context structures in Parrot 2.0.0

New in 2009-12 release
+ Only minor maintenance was done because all attention was being given
  to the Rakudo/ng branch, bringing in the new nqp-rx bootstrap compiler

New in 2009-11 release
+ Rakudo now uses Parrot's updated calling convention features
+ support unpacking of arrays, hashes and objects in signatures
+ changed .pick to use :replace instead of :repl
+ many core setting optimizations and bugfixes
+ IO::Socket.recv() has been extended to accept a parameter specifying the
  number of bytes which will be received
+ Rakudo now looks up %INC in the right namespace when loading libraries for
  foreign languages

New in 2009-10 release
+ smolder reports for spectest runs
+ more Complex trig functions
+ pure Perl 6 implementation of the Complex type
+ some variants of the new series operator
+ correct construction of twigilled colonpairs
+ infix:<eqv>, .pred and .succ for the Rat type
+ when configuring with --gen-parrot, pass --optimize to parrot's Configure.pl
+ moved more operators to the setting and thus made them overloadable
+ { %hash } now correctly constructs a hash, not a closure
+ new, faster low level Signature type
+ improved Signature introspection
+ new, much faster signature binder
+ improved various error messages related to signature binding
+ signature literals now supported
+ binding of named arguments to positional parameters
+ attributive parameters implemented
+ package blocks now run as immediate blocks, as per the spec
+ lexical variables declared outside of packages now visible inside them

New in 2009-09 release
+ updates to numeric operators: infix</>(Int, Int) creates a Rat
+ Rat (rational) numbers
+ overloadable builtin operators
+ contextual variables
+ setting values in %*ENV now works
+ partial support for trigonometric functions of complex numbers
+ better handling of custom traits, many builtin traits moved to core setting
+ improved type dispatch for builtin operators, type coercions

New in 2009-08 release
+ Rakudo must now be built from an installed parrot, and can be installed
  itself
+ separate Perl 6 meta class
+ introspection on roles
+ declaration of methods in the meta class by writing method ^newmethod($obj)
+ :tree options for parent class, attribute and role introspection
+ allow some custom postcircumfix:<( )> methods
+ moved more built-ins into the setting
+ implement operators infix:<!%> (divisibility test) and prefix [||] and [//]
+ updated ROADMAP in preparation for the Rakudo Star release
+ instead of throwing nasty parse errors, Rakudo now informs you that feed
  operators are not yet implemented
+ improved testing: planless testing with done_testing(); better diagnostic
  output from is()
+ the syntax for embedded comments has changed
+ embedded Pod comments are now recognized
+ support for defining traits and applying them to routines, classes and roles
+ "hides" trait (class A hides B { ... }), and "is hidden"
+ better handling of slurpy and optional in multi-dispatch
+ use of .?, .+ and .* with indirect calling form ($obj.+@cands)
+ .can improved; now returns something usable as an iterator
+ lastcall implemented

New in 2009-07 release
+ extensive refactor of the multi dispatch code to get closer to the spec
+ better handling of named arguments in multi dispatch
+ operators and traits can be defined in the setting
+ basic implementation of the series and eqv operators
+ refatored trait code to match updated specification
+ implemented more cases of smartmatching against hashes
+ fixed state variables to work with //= and ||= initialization
+ improved testing: when Rakudo dies with  'Null PMC Access' it is never
  considered a success
+ implemented the :all flag to split which keeps captures
+ added List.rotate builtin
+ nextwith and callwith now also work properly with methods
+ take() without outer gather now merely warns
+ introspection of roles and attributes

New in 2009-06 release
+ refactored and corrected object initialization (BUILD/CREATE)
+ attributes initilizations can now use attributes defined earlier
+ method calls are now faster
+ basic safe mode that forbids IO and execution of external programs
+ implemented meta operators for user defined operators
+ initial implementation of Temporal (date/time related objects)
+ type checking of implicit return values
+ improved introspection methods
+ cleaned up IO methods
+ improved "is export" handling for modules and setting
+ automatically transcode to iso-8859-1 for faster parsing when possible
+ refactored and corrected assignment, .succ, .pred, C<++>, C<-->,
  postcircumfix:<[ ]>, Whatever
+ "module Foo;"  now allows statements before it
+ improved Unicode string handling
+ better support for Str increment/decrement in Unicode ranges
+ many performance improvements

New in 2009-05 release
+ updated docs/ROADMAP
+ basic support for custom operators
+ operators can now be referenced as &infix:<+>
+ meta operator support for custom operators
+ cross-language library loading
+ stack traces now include source file name and line number
+ implemented Regex type
+ .WALK (parent classes in configurable order)
+ .name method on routines
+ refactored enums, thereby fixing many enum related bugs
+ fixed namespace of eval()ed code
+ implemented parallel dispatch (@objects>>.methods)
+ initial support for «...» quotes
+ text files now default to utf8 encoding
+ fixes to Match.perl and Match.chunks
+ implemented 'constant name = $value'
+ documented build dependencies
+ grep() accepts general matcher, things like @list.grep(Int) work
+ trigonometric functions (sin, cos, ...) now available via 'use Num :Trig'
+ qx{} quotes now work (except on Windows)
+ hyper-operators on hashes now work (%a >>+<< %b)
+ initial implementation of $foo.@bar
+ refactored wrap and unwrap to work with candidate lists; fixes some bugs
+ refactored/improved callsame and callwith, and added nextsame and nextwith
  (only work for dispatches of the form $foo.@bar and with wrap so far)
+ partial implementation of .^parents and .^methods
+ can initialize attributes in terms of others
+ many other bug fixes and performance enhancements

New in 2009-04 release (#16, "Bratislava")
+ wrap and unwrap for subroutines
+ calling a method on a Whatever star generates a closure
+ 1+*, *+1 and others generate closures (*-1 missing)
+ Associative, Positional and Callable are now parametric roles
+ typed arrays and hashes
+ parametric role subtyping (R[T1] ~~ R[T2] where T1 ~~ T2)
+ .invert and .push on Hashes
+ enforce return types of subroutines (partial implementation)
+ parallel testing
+ Configure.pl now supports passing options to parrot's Configure
+ support for lexical subroutines and multis
+ implemented \c[character name] in double quoted strings and regexes
+ implemented Perl 5 regexes
+ rx/.../ regex quoting
+ sockets support has been added (IO::Socket)
+ regex patterns may now be quantified by a separator regex
+ moved many methods to the setting
+ exporting and importing by tags, support :DEFAULT export tag
+ implemented START blocks
+ implemented roots builtin
+ implemented .ast on Match objects
+ added Match.caps and Match.chunks
+ split() now supports limits in all cases
+ prefix:<=> and the "fish operator" ( =<> ) are now gone
+ .readline is now .get
+ roles are now punned on any method call on the role
+ many other bug fixes

New in 2009-03 release (#15, "Oslo")
+ implemented $*PROGRAM_NAME magical variable
+ outer lexicals are now visible in eval()
+ next, last etc. work in grep()
+ added R metaoperator
+ add an initial draft of Match.perl
+ refactor Grammar and Match class hierarchy
+ fix if/unless/while/until/for/... on line after close curlies
+ add Q quoting, including Q:PIR
+ added "state" variables
+ //= fixed to short-circuit, and added short-circuiting &&= and ||=
+ multi-subs now have the Multi type and have a .candidates method
+ multi-method dispatch now looks up the class hierarchy
+ various fixes to using roles as type constraints
+ support bare sigils in signatures
+ more methods and functions moved to (Perl 6) setting
+ many other bug fixes

New in 2009-02 release (#14, "Vienna")
+ first release independent of Parrot releases
+ passing 7076 spectests (+796 since 2009-01 release)
+ build and use fakecutable (perl6.exe) by default
+ redesigned build, configuration, and test subsystems
+ add settings/ directory for builtins written in Perl 6 (was "prelude")
+ improve diagnostics in Test.pm
+ allow anonymous classes via C<::>
+ re-use existing parameterized roles instead of creating new ones
+ roles now pun classes when .new is called on them
+ 'proto' now marks all same-named routines as 'multi'
+ XopX is now Xop
+ implement <-> (rw) pointy blocks
+ added min= and max= metaoperators
+ many many bugfixes
+ publish release schedule
+ documentation improvements
