Fork me on GitHub
Downloads

Source releases: these are intended for using Duktape in your program.

DateFilenameDescriptionMD5
2013-09-21duktape-0.6.0.tar.xzalpha, first round of work on public APIfa384a42a27d996313e0192c51c50b4a
2013-10-30duktape-0.7.0.tar.xzalpha, tracebacks, portability fixes120978321dbf1f094fb893c945209179
2013-12-18duktape-0.8.0.tar.xzalpha, E5.1 fixes, compiler limit fixes294db51750f8c0153c361c09edffd2dc
2014-02-02duktape-0.9.0.tar.xzalpha, new features, bug/portability fixesd3db2ae0b1295e819e459516e112f93d
2014-04-13duktape-0.10.0.tar.xzalpha, API improvements, logging, bug/portability fixesa09355eee52d445fe1a1c3198377fca1
2014-07-11duktape-0.11.0.tar.xzalpha, modules, ES6 subset, bug/portability fixesab83f0a8d3473b3bc6dc82f0c48c2959
2014-09-26duktape-0.12.0.tar.xzbeta, bug fixes, stabilization release7d315a80c5e9937bd56ed5d8de9e638d
2014-10-26duktape-1.0.0.tar.xzstable baseline released0cf16dcafea3248e9f1860299fde5fa

Git repos: development git repo (with a lot of churn) is hosted at https://github.com/svaarala/duktape/. Unpacked source releases are available as tags in the https://github.com/svaarala/duktape-releases/ repo.

You only need to check out the git repo if you intend to change the internals of Duktape or want to use a bleeding edge version.


RELEASES

0.1.0 (2013-02-14)

  • Initial alpha release
  • Core features work: compiler, executor, regexps, garbage collection
  • Most built-ins incomplete or missing

0.2.0 (2013-02-27)

  • Built-ins implemented: Boolean, Date, JSON
  • Date built-in has initial, minimal local time / locale support
  • Initial internal documentation: regexp, datetime, json

0.3.0 (2013-03-16)

  • Built-ins implemented: global object, Object, String

0.4.0 (2013-03-31)

  • Built-ins: Array, Number, completing built-ins

0.5.0 (2013-05-17)

  • Built-in number conversion primitives
  • Cleanup built-ins, improve test cases for built-ins

0.6.0 (2013-09-21)

  • First round of public API cleanup, and add basic API documentation
  • First version of duktape.org website

0.7.0 (2013-10-30)

  • Traceback support improved
  • Clean up and document error object properties
  • Add prototype objects for buffer and pointer values, and make them object coercible
  • Proper support for big, little, and "middle endian" environments
  • Single file combined source distributable
  • Portability and bug fixes

0.8.0 (2013-12-18)

  • Remove DUK_PROFILE model, explicit DUK_OPT_xxx feature options added for tuning the build (see web docs)
  • Register shuffling added to compiler which mostly eliminates constant and temporary register limits
  • Reduce code footprint, make built-in data 'const' so that it compiles into the 'text' section
  • Augment errors created when a built-in error constructor is called as a normal function (e.g. "var e = Error('test')")
  • Enforce string/buffer length limits to avoid corner cases with strings and buffers close to size_t limit
  • Ecmascript E5.1 test cases and fixes
  • Mark-and-sweep stringtable leak fixed, affected mostly builds without reference counting
  • Run a few mark-and-sweep passes in duk_destroy_heap() to give finalizers a chance to run in most (but not all) cases
  • Coroutine yield fixes
  • Portability and bug fixes

0.9.0 (2014-02-02)

  • Added duk_gc() API call to force GC, implemented duk_map_string() and duk_decode_string()
  • Added extended JSON format variants JSONX and JSONC; NULL pointer values string now coerce to "null" instead of e.g. "(nil)" to match JSONX format
  • Added input line number to compiler error messages (e.g. SyntaxErrors)
  • Added support for function declarations outside function or program top level (also known as "function statements"), with V8-like semantics
  • Renamed __duk__ to Duktape for more consistency with Ecmascript conventions
  • Removed somewhat useless Duktape.build property and added Duktape.env
  • Replaced Duktape.addr() and Duktape.refc() with Duktape.info() which gives more internal info
  • Merged Duktape.setFinalizer() and Duktape.getFinalizer() into a single Duktape.fin() call
  • Some compatibility properties available for now (e.g. __duk__), but these will be removed after this release
  • Removed array size limit for very large array joins
  • Improve Unicode handling of Greek final sigma
  • Make mark-and-sweep interval relative to current heap size (measured as combined object and string count)
  • Add DUK_OPT_NO_VOLUNTARY_GC to disable voluntary mark-and-sweep entirely; this is useful in timing sensitive applications like games
  • Preliminary internal support for periodic bytecode executor interrupts which can be used to implement executor step limits, profiling, and debugging
  • More feature options for build tuning
  • More self tests to detect obscure compiler bugs, two's complement arithmetic, etc (enable with DUK_OPT_SELF_TESTS)
  • Fixed several compile warnings, fixed warnings generated by GCC -Wextra
  • Fixed some incorrect assertions (with no underlying bug)
  • Fixed a coroutine termination bug which caused assertion errors and occasional segfaults when an uncaught error terminated a thread with a catch point active
  • Fixed a tailcall bug: the current activation was not closed which caused variable lookups to fail if an inner function accessed variables in the surrounding activation
  • Fixed a few bound constructor bugs
  • Fixed handling of "get" and "set": they were handled as reserved words which prevented valid statements like "var set = 1;"
  • Fixed a switch-case bug where code was accepted before the first case/default clause
  • Fixed a switch-case bug where successive case clauses with no code in-between was not handled correctly
  • Fixed a for statement control flow bug when the third clause of the for statement was empty and a continue was used
  • Fixed error lineNumber bug triggered when there was more than 127 source lines between successive compiled statements
  • Fixed some line terminator handling issues
  • Fixed relational operator ToPrimitive() coercion order, for some operators coercion order was reversed
  • Fixed 'with' statement in strict mode (did not throw SyntaxError)
  • Fixed strictness handling of an indirect eval call from a strict function (eval incorrectly inherited strict mode)
  • Several test262 and underscore.js test case fixes (other than above)
  • Windows compatibility for both WIN32 and WIN64, tested with MinGW (x86), MINGW-w64 (x64), VS2010 Express (x32), VS2013 Express (x32 and x64)
  • Portability fixes for non-C99 platforms (like MSVC in VS2010)
  • Drop 'full distributable' build, which is replaced by the public GitHub repo; simplify Makefiles etc accordingly (this change is not visible in the source distributable)

0.10.0 (2014-04-13)

  • Avoid "out of regs" for large expressions by adding more comprehensive register shuffling and indirect variants of several bytecode opcodes
  • Change error handler model: error handlers are now set explicitly to Duktape.errcreate and Duktape.errthrow, and can interact with both error creation and error throwing
  • Incompatible API change: errhandler_index argument has been removed from all protected API calls as unnecessary
  • Add duk_push_heap_stash(), duk_push_global_stash(), and duk_push_thread_stash() to provide C code with stashes for storing values invisible to Ecmascript code
  • Add duk_safe_to_string() and duk_safe_to_lstring() to make it easier to write result printing in C
  • Add protected variants of eval/compile: duk_peval(), duk_peval_string(), duk_peval_file(), duk_pcompile(), duk_pcompile_string(), duk_pcompile_file()
  • duk_pcall_prop() now catches invalid stack index errors and property lookup errors which happen before the actual call
  • Add duk_put_function_list() and duk_put_number_list() to make it easier to define modules from C code
  • Add Duktape.compact(), Duktape.line(), and Duktape.act()
  • Add a "use duk notail" directive which indicates that an Ecmascript function should never be tail called
  • Add a barebones built-in logging framework with both Ecmascript and C APIs and easy customization
  • Add a message argument to fatal handler function callback, simplify internal fatal error and panic handling
  • Compact function templates and instances to reduce memory footprint
  • Execute finalizers for all objects, even reachable ones, when a heap is freed to allow native resources to be freed reliably
  • "new Object()" now promotes plain buffer and pointer values to Buffer and Pointer objects
  • Buffer values now have virtual numeric index properties and a virtual 'length' property, so that you can do x = buf[123], buf[123] = x and buf.length
  • Buffer data areas no longer have an automatic NUL terminator to avoid rounding user-requested allocation sizes upwards unnecessarily
  • Buffer constructor behavior changes: number argument creates a buffer of a certain size; optional second argument indicates whether a buffer should be dynamic or fixed
  • Change Array.prototype.splice() behavior so that if 2nd argument (deleteCount) is not given, splice to end of array instead of treating like deleteCount was zero: the new behavior is non-standard but is the real world behavior used by V8, Rhino, Spidermonkey, etc
  • Add an automatic 'length' property to Duktape/C functions
  • Add a feature option to provide a 'caller' property for non-strict functions, with behavior similar to the (non-standard) behavior in e.g. V8 and Rhino
  • Add a feature option to disable automatic zeroing of data areas of buffer values
  • Improve self tests to include byte order validation
  • Allow the global eval() function to be called from C code (causes an indirect eval); this was at least an issue with a bound eval() call
  • Fix O(depth^2) inner function parsing issue, inner functions are now only parsed once and deeply nested inner functions are no longer a performance issue
  • On platforms requiring a specific alignment, use an alternate object property table memory layout to reduce memory footprint
  • Wrap remaining platform calls through macro wrappers to allow easier targeted fixes if necessary
  • Fix a regexp bug: non-capturing groups inside quantifier expressions were matched incorrectly
  • Fix a regexp bug: capture groups were not reset to 'undefined' when a quantified with capture groups was re-matched by a quantifier
  • Fix a tailcall bug which caused assertion failures when a tailcall was made from inside a switch-case
  • Fix a with statement bug which caused assertion failures when a break or continue jumped out of the with statement
  • Fix a try-catch-finally broken assertion when finally block had finished (ENDFIN opcode)
  • Portability fixes for Crossbridge (Flash), NetBSD (endianness detection and a few Math.pow() fixes), OpenBSD (endianness detection), QNX (endianness and other fixes)
  • Warning fixes for non-default feature options and a few exotic compilers
  • Duktape can now be compiled with Emscripten and executed with e.g. V8, "Dukweb" provides an example where Duktape runs on a web page, with Duktape and the browser Javascript environment interacting

0.11.0 (2014-07-11)

  • Add a built-in module loader (i.e. a require() function) based on CommonJS modules v1.1.1; user must always provide a module search function (Duktape.modSearch)
  • Add Object.setPrototypeOf() and Object.prototype.__proto__, both borrowed from ES6 draft, to improve internal prototype handling
  • Add proxy objects borrowed from ES6 draft to allow property virtualization, subset limited to the following traps: has, get, set, deleteProperty, enumerate, ownKeys
  • Add property name as a non-standard setter/getter argument to make it possible to share a single setter/getter pair for multiple properties
  • Allow non-standard dollar escape inside character classes (previously they were already allowed elsewhere), to support non-standard regexps like /[\$]/
  • Add debug API calls to dump the stack top and values in the current context, see e.g. duk_dump_context_stdout
  • Add convenience API calls: duk_push_uint(), duk_get_global_string()
  • Add more variants for eval/compile (such as duk_eval_lstring() and duk_compile_lstring()) and avoid interning the source code when compiling from a user provided string (useful in low memory environments)
  • Add duk_copy() API call, essentially shorthand for duk_dup() + duk_replace()
  • Align duk_to_fixed_buffer() arguments and return value with duk_to_buffer() (this is an API incompatible change); add duk_to_dynamic_buffer()
  • Implement the DUK_COMPILE_FUNCTION flag for duk_compile()
  • Remove Duktape.line() as redundant to Duktape.act()
  • Serialize negative zero as '-0' in JSONX and JSONC
  • Public API C typing wrapped behind typedefs to allow porting to more exotic platforms, e.g. platforms where "int" is a 16-bit type; API docs updated to describe how type wrapping affects calling code (see new section "C types")
  • Internal C typing wrapped throughout to allow porting to more exotic platforms, e.g. platforms where "int" is a 16-bit type
  • Rename some feature options (DUK_OPT_xxx) for consistency, please check any options you use against the up-to-date options list
  • Rename Duktape.errcreate and Duktape.errthrow to Duktape.errCreate and Duktape.errThrow for naming consistency
  • Rename Duktape's custom JSONX format to avoid confusion with JSONx (XML encoding for JSON); new names are JX and JC ('jx' and 'jc' in APIs, DUK_OPT_NO_JX and DUK_OPT_NO_JC in feature options)
  • Compact the automatic function .prototype property, which previously had 1 unused property slot
  • Use 'anon' instead of 'empty' for the function name in toString() coercion of an anonymous function, matching traceback behavior
  • The expressions !0 and !1 are now constant folded by the compiler as they're often found in minified code; also !true and !false are constant folded
  • Remove the 256 character limitation for duk_log(), log messages can now be arbitrarily long but short messages (<= 256) are still formatted efficiently using a stack buffer
  • Improve non-C99 build: type detection should now work on (some) 64-bit platforms too, and non-debug build should now generate much fewer (or no) warnings; this also improves C++ build
  • Add support for X32 ABI (gcc -mx32 option)
  • Move platform and feature detection into duktape.h, also for internal types, which allows type wrappers to be applied to the public API
  • Add a safety limit for compiled bytecode byte size and maximum line number used to ensure pc-to-line internal data structure limits are not exceeded
  • Fix a number conversion related incorrect assertion triggered by the test262 test suite
  • Fix JSON.parse() handling for '__proto__' named own property, which should be parsed as a normal property of that name instead of changing the object's prototype
  • Fix a duk_push_sprintf() bug: for long formatted strings Duktape would reuse a va_list without copying it, which lead to memory unsafe behavior
  • Fix a 'delete' bug: if delete target was a string and key was 'length' or a valid character index, value stack was left in an inconsistent state in non-strict mode (caused an assertion failure)
  • Fix a rare math optimization issue in the Date built-in, which caused a corner case test (test-bi-date-canceling.js) to fail on e.g. 64-bit Ubuntu, gcc 4.8.1, -m32, and no -std=c99
  • Fix a few corner case pointer wrapping bugs in duk_set_top() and a few other value stack index handling functions
  • Portability fix for avoiding potentially non-portable signed integer constants internally (e.g. use 0x7fffffffL - 1L instead of -0x80000000L); this fixed a concrete problem with at least VS2010 + x64
  • Portability fix for avoiding direct function pointers to built-in functions (especially math functions) because they may be implemented as inline functions or macros on some platforms or polyfill headers
  • Portability fixes for MSVC, avoid secure CRT warnings to work better with Windows Store apps
  • Portability fixes for VS2010, avoid ending up with a packed value representation on x64 when standard integer headers are not available (also added a self test to catch such cases)
  • Reduce warnings generated by /Wp64 option of VS2010 when compiling for x86; the remainings warnings are harmless and cannot be completely removed, see guide documentation for more information
  • Portability fix for DUK_OPT_SEGFAULT_ON_PANIC when C99 types are not available
  • Portability fixes for uclibc, use a replacement for e.g. fpclassify() because it is broken in some uclibc versions still in use (affected at least some mixed endian ARM environments)
  • Portability fixes for newer Emscripten version, Dukweb.js now works with Firefox
  • A few polyfills for non-standard but still commonly used features are provided in the distributable polyfills/ directory
  • AUTHORS.txt is now included in the distributable, and both LICENSE.txt and AUTHORS.txt are embedded into duktape.c and duktape.h to ensure they're automatically included when used in another project

0.12.0 (2014-09-26)

  • Beta release for stabilization: feature freeze until 1.0.0 release, most work will be testing, bug fixes, and documentation
  • Remove undocumented duk_xmove(), add duk_xmove_top() and duk_xcopy_top() (duk_xcopy_top() provides the same semantics as the earlier undocumented duk_xmove())
  • Change strictness behavior for Duktape API calls: all API calls now have Ecmascript strict semantics, even when a call is made with an empty call stack outside of any Duktape/C function
  • Change strictness handling of duk_eval() and variants so that all code is evaluated in non-strict mode by default (unless the code itself contains a "use strict" directive); without this change the strictness would depend on whether a Duktape/C function call was active or not
  • Change Array.prototype.concat() and Array.prototype.map() behavior so that trailing non-existent elements are counted towards the result array length; this behavior seems to be non-standard but is the real world behavior used by V8, Rhino, and Spidermonkey at least
  • Add API call duk_set_global_object() which allows the global object of a context to be replaced; this is useful as an initial mechanism for proper sandboxing of Ecmascript code
  • Add API calls duk_get_prototype() and duk_set_prototype() for getting and setting an object's "internal prototype" from C code
  • Add API calls duk_get_finalizer() and duk_set_finalizer() for getting and setting an object's finalizer from C code
  • Add API calls for function "magic" which allows a 16-bit signed integer to be associated (cheaply) with a Duktape/C function
  • Treat any strings whose byte representation begins with 0xFF as internal, so that user code can use hidden internal properties like Duktape does internally; such properties are not enumerated or returned by e.g. getOwnPropertyNames()
  • Fix the object property allocation resizing algorithm to avoid unbounded memory usage with some insert/delete sequences (see test-bug-object-prop-alloc-unbounded.js)
  • Use an equivalent year (matching leap-year-ness and weekday of Jan 1) for local tzoffset calculations outside the [1971,2037] year range to improve local time handling
  • Use gmtime() + localtime() on Unix (instead of gmtime() twice) for local tzoffset, fixing some DST cases
  • Improve parsing of a local time (new Date(2012, 1, 2, 3, 4, 5)) using an iterative algorithm to get a more accurate tzoffset/DST estimate
  • Apply E5.1 Section 15.3.5.4 TypeError throwing also when the property value is a bound strict function, previously the special "caller" property behavior was only applied when "caller" value was a non-bound strict mode function
  • Reject deletion of plain buffer indexed elements (previously this behavior was implemented only for Buffer objects), i.e. delete returns false (in non-strict functions) or throws a TypeError (in strict functions)
  • Reject empty throw statement ('throw;') and reject a newline which occurs between a 'throw' and its argument
  • Disable internal interrupt mechanism in anticipation of 1.0 release since there will be no API to use it
  • Fix value stack reserve handling for function calls: a function call (Ecmascript or Duktape/C) might reduce the valstack "checked size" which was previously requested by user code (for more detail, see API test case test-dev-valstack-checked-size-call.c)
  • Fix finalizer handling for Proxy objects: if a Proxy object was reachable at heap destruction and the target object had a finalizer, the finalizer would also be executed for the Proxy object
  • Fix a few Date bugs for large out-of-range years which caused some assert failures and incorrect behavior when year was out of Ecmascript range (e.g. year 870e6 and year -200e6)
  • Minor compile warnings fixes for non-default options (e.g. when reference counting is disabled)
  • Make objects and functions defined by included polyfills non-enumerable so that they don't enumerate e.g. in a for-in loop
  • A few more polyfills

1.0.0 (2014-10-26)

  • Feature complete baseline release
  • Add convenience API call: duk_put_global_string()
  • Rename duk_is_fixed() to duk_is_fixed_buffer() and duk_is_dynamic() to duk_is_dynamic_buffer() for consistency with other API calls
  • Rename Duktape internal keys to start with an uppercase character (e.g. "\xFFValue") so that user internal keys which begin with a lowercase character (e.g. "\xFFptr") won't conflict by default
  • Add OS and compiler strings to Duktape.env
  • Make error 'tracedata' an internal property for better sandboxing
  • Rename members of struct duk_memory_functions to have a "_func" suffix, to avoid conflicting with standard library names (which is problematic if the standard names are #defines)
  • Add DUK_OPT_DLL_BUILD, which should be enabled for both Duktape and application build when Duktape is built as a DLL; on Windows it makes Duktape use __declspec(dllexport) and __declspec(dllimport) for public API symbols
  • Rename RELEASES.txt, AUTHORS.txt, and README.txt files to .rst suffix for better automatic formatting
  • Fix a mark-and-sweep finalizer bug which could cause memory safety issues when finalizer execution was disabled for a mark-and-sweep round
  • Fix a mark-and-sweep zero-size realloc() bug which could happen when an initial zero-size realloc() failed (this shouldn't normally happen but was triggered by GC torture testing)
  • Fix an assertion failure when using labelled block statements; some labelled block statements still cause an internal error ("INVALID opcode 0") but don't cause assert failures
  • Fix an assertion failure when using a try-catch in a function with a lot of constants (more than 511 string or non-integer constants); a compile error happens now instead to prevent unsafe behavior
  • Fix duk_dump_context_stderr() which incorrectly dumped to stdout
  • Fix require() resolution of relative module identifiers, which was off by one component (see GH-48)
  • Fix DUK_INVALID_INDEX define value, it used INT_MIN directly
  • Fix return value of Duktape.gc() to return true (instead of false) for a successful mark-and-sweep
  • Fix duk_peval_file(), duk_peval_file_noresult() and duk_pcompile_file() to avoid throwing an error for a missing file
  • Fix compile error for DUK_OPT_NO_FILE_IO
  • Regexp internal limit errors changed from Error to RangeError
  • Change command line example to be "barebones" by default, with readline enabled via DUK_CMDLINE_FANCY
  • Use variadic macros for VS2005+

Duktape is (C) by its authors and licensed under the MIT license.