Skip to content

Releases: knockout/knockout

Version 3.5.1

05 Nov 21:02
Choose a tag to compare

This release fixes a few regression bugs in 3.5.0:

  • Empty template with if option throws an error #2446
  • IE error from inserting a node before itself #2450
  • Problem with initial value binding on <select> when the options are generated via a foreach binding #2452
  • Missing arrayChange notifications when using deferred updates #2454
  • Template binding removes <script> template contents #2484

3.5.1 also fixes some issues with and expands 3.5.0's TypeScript definitions.

Version 3.5.0

22 Feb 07:10
Choose a tag to compare

Knockout 3.5.0 includes a few new bindings and new ways to interact with observables and bindings. The full list is detailed under 3.5.0 Beta, 3.5.0 RC, and 3.5.0 RC2.

The final 3.5.0 release includes fixes for a few regressions in the pre-production releases:

  • Fix performance issue with nested if bindings (#2414)
  • Fix exception with foreach and beforeRemove (#2419)
  • Fix misplaced nodes with foreach and Punches plugin (#2433)
  • Fix duplicated nodes with foreach and if (#2439)

3.5.0 Release Candidate 2

08 Sep 19:02
Choose a tag to compare

This release includes a number of fixes for regressions in the previous 3.5.0 release candidate. Given the time since the RC, we also decided to include a few small improvements.

  • Fix to maintain an element's focus when it's moved by the foreach binding.
  • Fix changes to style binding to correctly append px.
  • Fix regression to ko.contextFor when used after ko.applyBindingsToNode.
  • Revert changes in ko.utils to use native array methods.
  • Remove global createChildContextWithAs option and add noChildContext binding option. The default behavior for as matches previous releases.
  • Fix the interaction of descendantsComplete and if/ifnot/with bindings.
  • Add an option for if/ifnot/with bindings: completeOn: "render" will have the binding wait to trigger descendantsComplete until it is rendered.
  • Throw an error for unbalanced virtual elements.
  • ko.applyBindings throws an error if a non-Node is given as the second parameter.
  • Support an options objects as a parameter to createChildContext.
  • Support a custom rate-limit function as the method parameter to the rateLimit extender.
  • Support setting custom CSS properties with the style binding.
  • Optimize how many elements are moved by foreach.
  • Update TypeScript declarations.

We decided to keep the more standard return value for ko.utils.arrayFirst, which now returns undefined instead of null when no item matches.

3.5.0 Release Candidate

26 Apr 03:18
Choose a tag to compare

Changes since 3.5.0 Beta:

  • Expand descendantsComplete to include bindings other than component, such as if, with, etc.
  • ko.when will return a Promise if called without a callback function.
  • Include TypeScript declarations.
  • A few minor bug fixes.

Version 3.5.0 beta

29 Dec 18:17
Choose a tag to compare
Version 3.5.0 beta Pre-release

Knockout 3.5.0 beta release notes

Full list of issues:

Important: This release includes some minor breaking changes to the foreach binding to improve performance and clarify features. These changes can be turned off using global options.

  • When using the as option with the foreach binding, Knockout will set the named value for each item in the array but won't create a child context. In other words, when using as, you will have to use the named value in bindings: text: rather than text: property. This can be controlled by setting ko.options.createChildContextWithAs = true. (See #907)

  • To improve performance when array changes are from a known, single operation, such as push, the foreach binding no longer filters out destroyed items by default. To turn this off and filter out destroyed items, you can set includeDestroyed: false in the foreach binding or set ko.options.foreachHidesDestroyed = true to use the previous behavior by default. (See #2324)

Other enhancements

  • You can react to the completion of bindings such as if and with using the new childrenComplete binding or subscribing to the childrenComplete binding event.
    (See #2310)
  • You can react to the completion of components, including nested components, by including a koDescendantsComplete method in the component viewmodel or subscribing to the descendantsComplete binding event. (See #2319)
  • Binding strings can include template literals (backticks) and C++ and C-style comments.
  • Observable arrays include sorted and reversed methods that return a modified copy of the array. This is in contrast to sort and reverse that modify the array itself.
  • The new class binding supports dynamic class strings. This allows you to use the css and class bindings together to support both methods of setting CSS classes.
  • The new using binding, similarly to with, binds its descendant elements in the context of the child viewmodel. Unlike with, which re-renders its contents when the viewmodel changes, using will just trigger each descendant binding to update.
  • The new hidden binding works oppositely to visible.
  • The new let binding allows you to set values that can be used in all descendant element bindings, regardless of context.
  • Similarly to let, you can set such values at the root context by providing a function as the third parameter to ko.applyBindings. (See #2024)
  • Performance improvement: String templates are no longer parsed each time they are referenced. Instead the parsed nodes are cached and cloned.
  • Observables notify a new spectate event whenever their value changes. Unlike the standard change event, this new event isn't necessarily delayed by rate-limiting or deferred updates. You can subscribe to the event without waking a sleeping pure computed; the computed will notify the event if it is accessed with a new value.
  • Computed observables include a getDependencies method that returns an array of the observables that the computed is currently watching.
  • The attr binding supports namespaced attributes such as xlink:href in svg elements.
  • The ko.when function allows you to run code once when an observable or condition becomes true.
  • The ko.isObservableArray function can be used to check if something is a ko.observableArray.
  • The style binding will use jQuery if present. Even without jQuery, the binding now supports standard style names, such as background-color, and automatically appends px if needed to styles that expect it.
  • Knockout will throw an error if it finds an unmatched closing virtual element (<!--/ko-->).


30 or so separate fixes are included in this release,

Version 3.4.2

06 Mar 20:28
Choose a tag to compare

This release fixes a number of bugs related to deferred updates and computed observables.

  • stop infinite loop from dirty events in circular computeds (#1943)
  • only update a computed if dependency has actually changed; not if it was just dirty (#2174)
  • only notify subscriptions that exist when a change occurs; don't notify future subscribers (#2163)
  • notify dependent computed of change in reverted observable if the computed previously read a different intermediate value (#1835)
  • update a pure computed if a dependency has changed and notification is pending (#2197)

Version 3.4.1

08 Nov 07:11
Choose a tag to compare


  • pureComputed sometimes doesn't pick up a change in a dependency (#1975 and #1992)
  • Knockout observable arrays leak memory when resubscribing to arrayChange events (#1973 and #1974)
  • $rawData within with bindings and rendered templates (#1415)
  • Export computed._latestValue in debug mode (b3f24b1)

Version 3.4.0

17 Nov 00:29
Choose a tag to compare

New features and bug fixes

  • Improves performance of components, templates, computeds, and observables.
  • Includes a native version of deferred updates, along with a microtask queue (ko.tasks).
  • Calls a ko.onError handler, if defined, for errors from asynchronous code.
  • ko.options.useOnlyNativeEvents can be set to tell Knockout to use only native (not jQuery) events.
  • Includes ko.isPureComputed().

The 3.4.0 RC release notes has the full list of issues and pull requests included in this release. The final release fixes two regression bugs found in the RC:

  • #1903 - New beforeRemove behavior can break retained items.
  • #1905 - Endless recursion possible with ko.computed.

Possible compatibility issues

  1. Components now use microtasks to perform updates asynchronously instead of setTimeout. Since microtasks are run before the browser repaints the page, all loaded components will be initialized and displayed in a single repaint. Although this reduces the overall time needed to display components, it could result in a longer delay before anything is displayed.
  2. The new, native deferred updates feature has a slightly different API and is implemented differently than the Deferred Updates plugin. Migrating from the plugin will generally require some code changes (full details to come soon).
  3. ko.observable and ko.computed no longer use a closure when defining their methods, such as dispose and valueHasMutated. These functions expect this to be set correctly and so can't be used directly as a callback. Instead you'll need to use bind, such as obs.dispose.bind(obs).

3.4.0 Release Candidate

12 Oct 21:47
Choose a tag to compare

Knockout 3.4.0rc release notes


  • #1715 - Add ko.onError handler that provides more consistent error/stack information for async operations and event handlers
  • #1728 - Include deferred updates functionality in Knockout core
    • #1738 - Deferred Updates 1 - ko tasks functionality; deferred extender for enabling deferred Updates
    • #1753 - Deferred Updates 2 - add ability to turn on deferred updates globally by setting ko.options.deferUpdates = true;
    • #1795 - Deferred Updates 3 - dependency tree scheduling
  • #1774 - Add ko.options.useOnlyNativeEvents (default false) that can control if KO uses jQuery (if available) for binding events
  • #1839 - Performance Improvement - for named templates that use a template or normal element use the element directly as the template to clone
  • #1840 - Performance Improvement - Make observables 2-3x faster to instantiate and reduce memory usage by 50%
  • #1841 - Performance Improvement - Make computeds 2x faster to instantiate and reduce memory usage by 50%
  • #1870 - Add ko.isPureComputed.


  • #1256 - Better handling when an item is added while a beforeRemove animation is running
  • #1380 - observableArray sort and reverse methods now return the observableArray rather than the underlying array
  • #1510 - Do not define a custom element when a component name matches a standard element
  • #1591 - Make checked binding work properly with writable computed observables
  • #1613 - IE8 issue with calling .apply with an empty second argument
  • #1683 - Rearrange code to avoid prototype issue in Opera mobile
  • #1709 - dontLimitMoves option should be respected when comparing arrays
  • #1718 - ko.toJS no longer replaces RegExp objects with plain objects
  • #1756 - Use a hasOwnProperty check when registering components
  • #1781 - Trim string in default css binding
  • #1783 - Skip template elements when binding
  • #1788 - Fix textInput edge case in IE9
  • #1790 - Remove version from bower.json and don't update it in build
  • #1794 - Exception in an afterAdd callback should not cause duplicate elements
  • #1810 - Don't check for require for CommonJS
  • #1855 - Fix potential memory leak in component binding
  • #1893 - hasFocus fixes in IE

Version 3.3.0

18 Feb 22:29
Choose a tag to compare


#1504 - Component configuration can specify a synchronous option to render already loaded components synchronously.
#1463 - Component child elements are provided to the createViewModel method, component child elements are exposed on the binding context as $componentTemplateNodes, and the template binding can accept an array of DOM nodes directly through the nodes option.
#1449 - Binding context now contains a $component property that references the nearest component view model (allows for easily binding to the root of the current component).
#1596 - Create a writable computed within a custom element component when an expression evaluates to an observable (less need to use .$raw property).
#1576 - computed observables (pure or deferred) notify an awake event with the current value when awakening, pure computeds notify an asleep event with an undefined value when going to sleep, and the getSubscriptionsCount method on an observable can accept an event name argument to return only the count of subscriptions for that event.
#1543 - Sleeping pure computed observables now cache their value.
#1635 - Export ko.utils.setTextContent
#1427 - Export ko.dependencyDetection.ignore as ko.ignoreDependencies


#1321 - Ensure that template nodes are created and moved within the correct document to fix cross-window issues in IE.
#1434 - Binding parser skips all colons between the name and value. Support returning malformed bindings (non key-value pairs).
#1468 - css binding was not clearing a previously added dynamic class when the value bound against changes to null.
#1507 - Memory leak fix for foreach/template binding
#1513 - Fix error in fixUpContinuousNodeArray when using jquery.tmpl
#1515 - Update dependentObservable._latestValue when a pureComputed wakes up (affects debug build only)
#1526 - Component's require option should not try to do an AMD-style require in a CommonJS scenario.
#1556 - Check that the value passed to optionsAfterRender is a function before calling
#1597 - CSS binding now works properly with SVG elements
#1606 - Don't bind contents of <textarea> elements
#1623 - When using valueAllowUnset: true, null selection should be maintained when option items are updated.
#1634 - Better clean-up of arrayChange subscriptions