Release Notes


  • Added additional detail to client-side error messages when an invalid response is received from the server to assist in debugging network issues.
  • Added additional error handling in the server for null bindings and subscriptions in the event of bad data.
  • Added Subscribers extension to NET.Server.HttpListener as that is the required setup for IceLink signalling.
  • Updated the SQL provider to allow up to 256 characters for binding keys (previous limit was 64).


  • Removed deprecated Silverlight and Windows Phone examples.


  • Improved HTTP performance for native iOS and macOS.
  • Fixed potential memory leak in the NET.Server.HttpListener example.


  • iOS and macOS libraries are now using NSURLSession for HTTP requests to avoid deprecation warnings.
  • JavaScript SDK will use WebSockets by default if the server indicates support.
  • Fixed bug in domain-key re-write logic in PHP proxy class.
  • Fixed bug in cache service when duplicating records.
  • Updated WebSync event scanner to avoid duplicates if included in Global.asax.cs.


  • Fixed bug causing unexpected behaviour when adding multiple WebSyncEvent attributes to a single method.
  • Fixed bug where unhandled exceptions in callbacks attached to the Chat extension could cause an application crash.


  • Added Objective-C headers for Swift 3.
  • Added check in JavaScript WebSocket wrapper to avoid closing twice on sockets that are closed while sending.


  • Fixed bug in Java URI handling for WebSocket (duplicate query parameters).


  • Added optional "protocol" parameter to WebSocket constructor.
  • Added Publisher.Service and WebSyncServer.Service API.
  • Updated Async method overloads so they invoke OnSuccess/OnFailure/OnComplete.
  • Updated fm.xhr/postMessage/jsonp to better support usage outside of WebSync.


  • Fixed issue in JavaScript SDK that could result in duplicate headers for XHR requests.


  • Fixed bug in JavaScript Client so custom headers are sent with WebSocket requests.
  • Fixed bug in JavaScript Publisher related to transport tests prior to sending.


  • Fixed bug in OnHttpRequestCreated for JavaScript XHR transport.
  • Fixed bug in OnHttpRequestCreated for JavaScript WebSocket transport.
  • Removed support for Windows Phone 7.
  • Removed AppTransportSecurity bypass from iOS, macOS, and tvOS examples.
  • Updated JavaScript JSON serializer to catch attempts to serialize undefined values.


  • Updated DNS refresh in cache provider to respond faster to DNS changes after a cache failover.
  • Updated WebSyncEventAttribute to allow multiple attributes per method.


  • Fixed null reference exception in server event handling.


  • Added WebSyncEventArgs.Filter property as a way to read the current filter.
  • Added WebSyncEventArgs.FilterType property as a way to read the current filter type.
  • Added WebSyncEventArgs.Execution property as a way to get the current execution mode.
  • Added WebSyncEventArgs.Extensions property as a way to iterate over backing message's Bayeux extensions.
  • Fixed possible null reference exception in WebSocket class under load.


  • Updated Azure cache accessor to eliminate possible stack overflow on slow cache.


  • Added libraries for Xamarin.tvOS.
  • Fixed interop bug for WebSync 3 clients.


  • Updated performance tuning wizard to 1.1.1 - fixes default value for HTTP MaxConnections.


  • Added WebSyncEventArgs.Successful setter.
  • Added WebSyncEventArgs.Error setter.
  • Fixed a possible stack overflow in FM.WebSync.AzureCaching.
  • Fixed a bug where using the Notification class would cause the server to create a PublishInfo instead of a NotifyInfo in the event handler.


  • Fixed bug in JavaScript synchronous XHR handler raised if the request was aborted.


  • Updated Java HTTP submodule to enforce HTTP timeout manually when platform doesn't enforce it.


  • Updated Disconnect logic to cancel existing reconnection if a loop is running.
  • Updated Disconnect logic to only raise an error in the case where Disconnect is called before a previous call has finished.


  • Fixed bug in PublisherQueue where returned publications had Successful set to false.
  • Fixed bug in PublisherQueue where exceptions were not handled gracefully.
  • Improved error message when server does not have the Subscribers extension but the client expects it.
  • Updated Chat extension to better handle case where server does not have the Subscribers extension.


  • Fixed bug in JavaScript where WebSocket might not raise OnStreamFailure if the network was disconnected.
  • Updated WebSync Cache install wizard to allow some extra settings when installing just the manager.


  • Added server address to WebSync Cache install wizard.


  • Fixed bug where using postMessage could interfere with FM.Server's postMessage listener.


  • Added Windows 10 Universal libraries.
  • Updated Java HTTP transfer to allow proxies.


  • Enabled full bitcode for all iOS/Mac libraries (no more bitcode markers).
  • Fixed Xamarin.Android example warnings (XA0101: @(Content) build action is not supported).
  • Removed extra "return" statements in JavaScript (causing warnings in Firefox).


  • Fixed race condition where a chain of callbacks could be released mid-execution.
  • Fixed warnings in iOS/Mac libraries regarding being built for a newer version than being linked.


  • Added client.get/setDisableJSONP to the JavaScript SDK.


  • Added example for tvOS.
  • Fixed bug in Java SDK where removing an event handler might not have the desired result.
  • Improved performance in iOS/Mac SDK by streamlining data access.


  • Added libraries for Apple tvOS.
  • Added awaitable async overloads for asynchronous methods in Xamarin SDKs.
  • Fixed a bug where WebSocket events might not fire on iOS/Mac.
  • Fixed a bug where JSON might be incorrectly treated as binary.


  • Fixed bug in iOS/Mac where JSON validation might crash on malformatted JSON.
  • Improved error reporting when using incorrect names for callback functions in JavaScript.


  • Updated examples to use iOS 6 as deployment target.
  • Updated examples to bypass AST for iOS 9.
  • Removed JSONKit from examples (uses native NSJSON now).


  • Fixed bug where server-side Unbind events would not fire if client was forced to disconnect and not subscribed to any channels.


  • Updated JavaScript minification to use UglifyJS (slightly larger output, but more safe).


  • Updated client behaviour to default to long-polling (WebSocket protocol must be enabled explicitly).


  • Added support for setting CrossOriginResourceSharing.AllowedHeaders/AllowedMethods at runtime.
  • Added CrossOriginResourceSharing.AllowedOrigins to support a white-labelled list of allowed domains (defaults to null, which allows any origin).
  • Added DNS resolution for Cache provider to support DNS-based failover.
  • Updated CrossOriginResourceSharing.AllowedHeaders/AllowedMethods to be a string array instead of generic string list.


  • Updated WebSocket implementation to properly handle case where server indicates support for WebSockets but returns a 200 OK handshake response.


  • Fixed bug in Java SDK where client might not back-off from WebSockets to long-polling gracefully.
  • Fixed bug where connections might fail if the JavaScript environment (i.e. Node.JS) doesn't have a WebSocket implementation, but the server supports WebSockets.
  • Updated AMD headers in JavaScript SDK to support module naming.


  • Added AMD/Node dependency mappings to JavaScript modules.
  • Added Windows 8.1 libraries.
  • Added Windows Phone 8.1 libraries.
  • Added Windows Phone Silverlight 8.1 libraries.
  • Added Windows Phone 8.1 Portable libraries.
  • Fixed bug in WebSocket client to handle WebSocket servers that only support small frame sizes.
  • Updated iOS/Mac SDK deployment targets to iOS 6.0 and Mac OS X 10.7 to avoid linker warnings in Xcode 7.


  • Added AsyncException.Rethrow property to control the re-throwing of exceptions in application code callbacks.
  • Added support for Arabic locales in Java string formatting.
  • Updated AsyncException so it never re-throws ThreadAbortException.


  • Added armv7s slice for iOS libraries.
  • Added ConnectArgs.OnStateRestored callback, invoked when all subscriptions/bindings are restored following a reconnect.
  • Fixed bug in Windows 8 TCP socket wrapper.
  • Fixed bug in Windows 8 timeout timer.
  • Improved client-side performance for large subscription requests (over 1000 channels).
  • Updated Subscribe method so an OnReceive callback is no longer required.


  • Updated iOS/Mac SDKs to use weak references for callbacks to prevent retention cycles.


  • Fixed bug where InProcProvider would return null when querying for a specific client.
  • Updated Dynamic objects so cloning can never run into "collection modified" exception.
  • Updated built-in JSON serializer/parser to improve performance.


  • Fixed memory leak in WebSync chat extension.
  • Updated .NET TCP socket to include additional error handling.
  • Updated TimeoutTimer to accept negative values (indicates infinite timeout).


  • Added StreamFailureArgs.Retry to indicate whether or not to enter reconnect cycle.
  • Added additional logging in JavaScript when an exception is thrown in a callback.
  • Added fix for missing 'response' property in XHR requests in node.js 0.12.
  • Updated Disconnect method to better handle cases where invoked mid-disconnection.
  • Updated Cocoa TCP socket to gracefully shut down thread when closing.
  • Updated Xamarin.Mac SDK for compatibility with current release.
  • Removed ManagedMonitor. Replaced with ManagedLock and ManagedCondition.


  • Updated Chat extension to bypass user lookup if the user ID isn't present in a received message.


  • Fixed bug that could cause TCP socket failure on iOS/Mac.


  • Added JoinArgs.OnUserClientJoin and JoinArgs.OnUserClientLeave to provide notifications when individual clients join/leave.
  • Added ChatUser.ChatClients array to see all clients associated with user ID.
  • Added non-string detection in JavaScript SDK to help alert to situations where non-strings are passed into string parameters.


  • Fixed bug in Chat extension that would cause some leave notifications to not fire.
  • Updated WebSocket implementation in JavaScript to detect stream failures earlier.


  • Fixed bug where DNS might resolve to an empty array on iOS.
  • Updated Chat extension to eliminate any possibility of unhandled exceptions during join/leave operations.
  • Updated TCP socket implementation on all platforms to support additional features.


  • Updated Xamarin.iOS SDK to the new Xamarin Unified API (required for 64-bit support).
  • Updated Xamarin.Mac SDK to the new Xamarin Unified API.
  • Updated Chat extension to log warning instead of throwing an exception when an incompatible client joins.
  • Updated documentation.


  • Added Xamarin.Mac client libraries.
  • Fixed bug in disconnect operation of SQL stateless provider.
  • Updated server responses to always format as UTF-8, regardless of machine-level settings.


  • Updated server to only enforce security on remote (i.e. network) requests.
  • Updated Windows Phone SDK to disable WebSockets by default (avoids internal .NET exception).
  • Updated documentation.


  • Added BoundRecords property to ChatUser in Chat extension.
  • Fixed bug in Chat extension where a user join/leave notification might not fire.


  • Updated JavaScript null/empty string checks to also test for undefined variables.


  • Updated documentation.


  • Fixed bug where iOS callbacks might not execute on 64-bit processors.


  • Updated Chat extension to reset user cache after a connection failure.


  • Reverted bug fix for waking WebSockets on iOS Safari.


  • Fixed bug where iOS apps might crash when performing an atomic increment.


  • Fixed bug where client would not reconnect after waking when using WebSockets on iOS Safari.
  • Updated Chat extension to support multiple channels.
  • Updated Chat extension to support SubscribedClient property on UserJoin event.
  • Updated Chat extension to support UnsubscribedClient property on UserLeave event.
  • Updated Android HTTP transport to handle requests with no output data.


  • Updated default .NET JSON serialization to retrieve type from argument instead of generic argument.


  • Added JsonProvider framework.
  • Added FM.JsonNet extension for using Json.NET with WebSync for .NET.
  • Updated HTTP transfer to use system proxy if present by default.
  • Updated HTTP transfer to set content length to zero when posting with no data (resolves 411 server response).
  • Updated type loading to handle edge-cases where type is defined multiple times in different assemblies.
  • Updated documentation.


  • Added shortened method overloads to iOS/Mac SDKs.
  • Fixed bug in iOS/Mac NameValueCollection string comparison.
  • Updated iOS/Mac HTTP transfer so requests complete, even if calling thread goes away.


  • Added thread-safety to binary message serialization.
  • Added automatic backoff to JSON message serialization if binary message serialization fails.
  • Added additional error handling to web request transfer in Java SDK.
  • Added OnUnhandledException event to Client to help track down unhandled async exceptions in user code.
  • Added additional error handling to callbacks in Chat/Subscribers extensions.
  • Added explicit aborting to timed out web requests in .NET to avoid potential unmanaged leak.
  • Added FM.HttpWebRequestTransfer.UseProxy in .NET to force clients to use system-wide proxy.
  • Updated client to retry the WebSocket protocol if the protocol was successful on a prior connection.
  • Updated server to generate warnings when security attributes are attached to After events.
  • Updated handling of async exceptions to provide additional information and write to the log.
  • Updated documentation.


  • Added code snippet showing how to add/remove CORS headers/methods.
  • Updated Java SDK to use native types wherever possible (general performance improvement).
  • Updated cache service to ignore HEAD requests.
  • Updated JavaScript cookie storage/retrieval so special characters (like commas) are encoded/decoded.
  • Updated Bayeux connection type deserialization to ignore unrecognized connection types.
  • Updated chat extension to client always requests server notifications, whether or not callbacks are specified.
  • Updated JavaScript JSON date parsing to avoid issues deserializing strings that contain Date definitions.
  • Updated documentation with information about using Mono on the server.


  • Updated postMessage protocol to fall-back to JSON-P if the DOM fails, regardless of previous success.


  • Added WebSyncRelayBinding for hosting a WCF service using a WebSync client.
  • Added WCF extension to WebSync On-Demand SDK.
  • Added WCF binding overloads for various client configurations.
  • Added Silverlight support for WCF extension (client-only).
  • Added Unity support for WCF extension (client-only).
  • Added Windows 8 support for WCF extension (client-only).
  • Added Windows Phone support for WCF extension (client-only).
  • Added Xamarin.Android support for WCF extension (client-only).
  • Added Xamarin.iOS support for WCF extension (client-only).
  • Added Mono system libraries to the assembly scanner's exclusion list.
  • Fixed possible null reference exception in wait thread.
  • Fixed possible shared data object issue in mesh provider.
  • Updated Unity libraries to use .NET 3.5 client profile.
  • Updated WCF bindings to always use duplex communications.
  • Updated config initialization to avoid internal Mono bug.
  • Removed constructors that accept domain name from WebSync On-Demand SDK for Silverlight.
  • Removed WCF extension dependency on Subscribers extension.


  • Added WCF bindings for WCF simplex and duplex service hosting using WebSync.
  • Added RequestTimeout to client methods to override client-level timeout setting.
  • Updated Android examples.


  • Added awaitable Async method overloads for Windows Phone libraries.
  • Disabled automatic proxy detection in .NET to improve initial request time.


  • Added ability to set extension values using object-literal shortcuts (i.e., client.connect({ username: 'jdoe' });)
  • Added WebSyncProxy (in FM.WebSync.Server.dll) to WebSync On-Demand SDK.
  • Added x86_64 slice to iOS libraries (64-bit simulator).
  • Added null handling to default JSON serializer in .NET.
  • Added Visual Studio 2013 support to examples.
  • Improved error message when using a malformed object-literal shortcut in JavaScript.
  • Fixed bug in iOS where a client might not reconnect after an HTTP timeout.
  • Fixed date handling in default JSON serializer in JavaScript.
  • Fixed bug where examples/demos might use an old JavaScript client.


  • Added WebSync 4 On-Demand SDK.
  • Updated server network parser to reset network stream before reading (to support HTTP modules that pre-process the stream).
  • Fixed date serialization bug for Java.
  • Fixed date serialization bug for iOS/Mac.
  • Fixed date serialization bug for JavaScript.
  • Fixed UTF-8 encoding bug in JavaScript.
  • Fixed bug where clients might incorrectly be detected as idle on the server when the security extension is disabled.
  • Removed Json class from Xamarin.Android library for compatibility with Xamarin Indie development (JsonLite is still available).
  • Updated documentation.


  • Added DomainName to WebSyncEventArgs.
  • Added EventContainer attribute to ReturnData/Subscribers server extensions for targeted loads.
  • Added parameter value encoding to all outgoing requests.
  • Added exception handling for bad references during assembly load.
  • Updated WebSync Cache receive algorithm to avoid StackOverflowException on massive payloads.
  • Updated error handling in NET.Server.HttpListener to avoid ProtocolViolationException caused by HEAD requests.
  • Updated documentation with information about clean integration with NewRelic.
  • Updated documentation with notes about Amazon ELB (Elastic Load Balancer).
  • Updated documentation with details about HTTP Compression (gzip) performance tuning.
  • Fixed bug when using postMessage for HTTP transfers to a wildcarded domain.
  • Removed cache buster when using XHR for http transfers so CORS pre-flight requests are re-used.


  • Added AMD/CommonJS wrappers for JavaScript libraries.
  • Added paranoid error handling to WebSync cache service.


  • Added ConnectArgs property to StreamFailureArgs.
  • Added NET.WebSocketTest example.
  • Added server-side INFO-level log messages when WebSockets are enabled.
  • Added TextViewLogProvider to fm.jar for Android.
  • Added FMTextViewLogProvider to libFM.a for iOS/Mac.
  • Added TextBlockLogProvider to FM.dll for Windows 8 and Windows Phone.
  • Renamed NSMutableArray's setObject:atIndex: to setObj:atIndex: to avoid conflict with private Cocoa Foundation method.
  • Updated XHR layer so responseType is not sent for synchronous requests (avoids console error).


  • Fixed bug in base64 implementation in iOS/Mac.
  • Fixed bug in server where incoming messages might be treated as binary instead of JSON from iOS/Mac clients.
  • Updated JavaScript fm.consoleLogProvider to use newlines instead of HTML line break tags.


  • Added raw binary support for browsers that don't identify Uint8Array as a function.


  • Added support for directly sending, receiving, and processing raw binary data buffers in JavaScript.
  • Added fm.consoleLogProvider to JavaScript.
  • Added static quick-constructors for iOS and Mac.
  • Fixed WebSocket bug where frames sized between 32768 and 65535 bytes in length would cause a parsing failure.
  • Fixed bug where a network failure could cause a tight loop of retries in the client.
  • Updated handling of binary data buffers to improve performance on large data packets.
  • Updated documentation.


  • Fixed bug in WebSync Cache installer.
  • Updated Android examples to use minimum API level 16.


  • Removed WebSync Cache installer from Express SDK.
  • Updated documentation.


  • Added WebSync Cache Service installer.
  • Added TextLogProvider for string-based in-memory log capturing.
  • Added MaxBatchSize to PublisherQueue to limit the maximum batch size (defaults to 1000) to prevent collapse under millions of simultaneous publications.
  • Fixed bug in JavaScript where network failures could cause a permanent fallback to JSON-P in browsers that support newer techniques.
  • Fixed bug in JavaScript when formatting strings with > 3 arguments.
  • Updated Client.Service so DataJson is no longer required (similar to a GET call).
  • Updated Client.GetSubscribedChannels() so duplicates are not returned.
  • Updated LogProvider to simplify implementations.
  • Updated fm.domLogProvider in JavaScript to include UTC timestamps.
  • Updated JavaScript to support post-DOM loading (i.e. via modernizr).
  • Updated documentation and fixed some formatting issues.


  • Added libraries built specifically for Unity.
  • Added PublisherQueue for easier remote Publisher management.
  • Updated documentation.


  • Added ReconnectAfter property to support modifying the reconnect interval in the OnReceive handler.
  • Added First Steps guide to SDK.
  • Updated cache service to differentiate between properly failed requests and exceptions.
  • Updated cache service so bad data is caught and discarded instead of possibly entering an infinite loop.
  • Updated Java to use primitive byte instead of Byte to improve performance.
  • Updated ParseAssistant to use the invariant culture so numbers are consistently parsed.
  • Fixed bug where cache service would not recognize GetClient requests.
  • Fixed string formatting bug in Java/Objective-C for formats with more than 4 arguments.
  • Fixed bug where events might not fire after adding/removing callbacks in Cocoa.
  • Updated documentation.


  • Updated JavaScript libraries so an error is thrown if scripts are loaded in the wrong order.
  • Updated iOS examples with minor UI fixes.


  • Added new high-performance, in-memory cache service and provider.
  • Added client-side Forced property to Unbind/Unsubscribe success/complete event arguments.
  • Added client-side forced Unbind/UnsubscribeSuccess/Complete events after a disconnect or stream failure.
  • Added new server example using Azure Caching provider.
  • Added new server example using new cache provider.
  • Added new auction demo using Knockout.
  • Added WebSyncProxy to FM.WebSync.Server to support proxying of WebSync requests using WebSyncEventArgs-based callbacks.
  • Added fm.domLogProvider for JavaScript.
  • Added support for using blocks as callbacks in iOS/Mac.
  • Fixed bug where setting extension values on a message might not flag it as dirty for reserialization.
  • Fixed bug in JavaScript GUID comparison.
  • Fixed security exception thrown when using the Azure Caching provider and the new Azure Caching 2.0 SDK.
  • Updated Chat extension to only subscribe to meta-channel for events if OnUserJoin or OnUserLeave are specified.
  • Updated Azure Caching provider to use the new Azure Caching 2.0 SDK.
  • Updated error handling in bounded thread pool to handle a wider range of provider responses.
  • Updated documentation.
  • Updated iOS/Mac examples to use new block-based callbacks.
  • Removed FM.WebSync.Proxy (see WebSyncProxy in FM.WebSync.Server).


  • Added Log class to FM library for client-side logging.
  • Added native Android examples.
  • Added PHP examples.
  • Added node.js example.
  • Added "Collaborative Mapping" demo.
  • Added "ExtJS Stock Ticker" demo.
  • Added "Multipage Chat" demo.
  • Added "Photo Phun" demo.
  • Revamped examples for easier navigation and more relevant use cases.
  • Renamed MonoDroid/MonoTouch to Xamarin.Android/iOS.
  • Updated documentation.


  • Fixed JavaScript bug.


  • Added experimental MeshProvider provider to deploy WebSync clusters without a back-end cache.
  • Added new code snippet: "Using node.js"
  • Added new code snippet: "WebSyncServer Remote Publish"
  • Updated JavaScript client to support use within a node.js application.
  • Updated SQL provider schema to always include a CLUSTERED index to address recently added SQL Azure restrictions.
  • Updated iOS/Mac libraries to resolve issues associated with incorrect detection of null values.
  • Updated error message to be more friendly when sending a notification without a target client ID.


  • Added Single Sign-On demo using Windows Identity Foundation.
  • Added overloads for WebSyncServer.Subscribe/Unsubscribe/Bind/Unbind that trigger client-side events (OnServerSubscribe, etc.).
  • Added FMNSLogProvider for iOS/Mac.
  • Added ConsoleLogProvider for .NET/Silverlight/Windows/Windows Phone.
  • Added ConsoleLogProvider for Java.
  • Fixed bug in JavaScript where memory might leak in IE8/9 after repeated page refreshes.
  • Fixed bug in JavaScript where WebSocket initialization error using IIS Express on Windows 7 might throw to console.
  • Fixed bug in JavaScript where relative WebSocket URLs might not be absolutized properly.
  • Fixed bug in Mono for Android example.
  • Fixed NullReference exception when processing client requests after the server failed to load.
  • Updated documentation.


  • Added "threadsPerCPU" web.config setting.
  • Added periodic delivery metrics to DEBUG log output.
  • Added new auction demo for .NET/JavaScript.
  • Added new basic auction/chat demos for .NET/JavaScript.
  • Fixed bug in Java binary Bayeux deserialization.
  • Fixed bug in iOS/Mac binary message transfer.
  • Fixed bug in JavaScript WebSocket URL construction.
  • Fixed bug in JavaScript to avoid prompt when leaving the page in IE.
  • Various performance improvements for iOS/Mac.
  • Updated server-side WebSocket implementation to catch additional exceptions.
  • Updated documentation.


  • Added GetSubscribedChannels overload with "tag" parameter for client.
  • Added null-checks to Publication/Notification-Message conversion to prevent exceptions if a Publisher request fails.
  • Updated WebSyncEventArgs so properties can be set in a Before event using SetDynamicValue and retrieved in an After event using GetDynamicValue.
  • Updated JavaScript auto-disconnect cookie to include token to accomodate sticky load balancers.
  • Updated NSString comparisons in Cocoa to properly check for nil.
  • Updated migration guide.
  • Updated download package layout.
  • Updated documentation.


  • Added domain header to WebSocket handshake in JavaScript.
  • Added WebSyncServer.GetClient to server-side API.
  • Added new logic to significantly reduce server load when recycling and speed up idle client detection.
  • Added client-side logic to JavaScript client to speed up idle client detection when navigating or refreshing pages.
  • Fixed bug in .NET 4.5 server library that might break connections when using WebSockets.
  • Fixed bug in subscribers extension where subscription size might increase after a reconnect.
  • Improved server initialization time.
  • Updated documentation.


  • Added assemblies for Windows Phone 8.0.
  • Added "sync" extension for jQuery which uses WebSync to synchronize DOM/form contents among multiple web browsers.
  • Updated Azure Caching provider to use the the latest Azure SDK (

  • Added absolutization of WebSocket URLs to work around an issue with WebSocket initialization in Chrome.
  • Added MVC4 examples.
  • Improved serialization performance when using FM.Serializer.
  • Fixed bug where backoff index would not reset to zero after a stream failure/reconnect.
  • Fixed bug where WebSyncSecurity-enabled events without an HTTP context could throw an exception.
  • Updated exception text to be more helpful when an OnServerSubscribe event is not defined or returns null.
  • Updated server response handling so DisableBinary is honored for responses sent over streaming connections.
  • Updated SQL Server provider to recover if server records are deleted from the database by a third party.
  • Updated documentation.

  • Reduced the size of the JavaScript client.
  • Added Client.ConnectAsync/SubscribeAsync/etc. overloads for .NET 4+ and WinRT to allow the use of await/async.
  • Added GetUserId and GetUserNickname to WebSyncEventArgs when the chat extension is loaded.
  • Fixed caching bug in postMessage transfer layer (JavaScript).
  • Updated JSON-P client implementation to reduce URL size.
  • Updated binary message deserialization to handle null request bodies.
  • Updated clients to throw exceptions as unhandled when an unhandled exception occurs in a user-supplied callback.
  • Updated documentation.

  • Added instance-level Success/Failure/Complete events to the client.
  • Added WebSyncServer.DisableSecurityExtension for compatibility with third-party Bayeux clients.
  • Renamed static-level Complete events to End events.
  • Fixed memory leak in iOS/MacOS client libraries.
  • Fixed bug in binary message array deserialization.
  • Fixed bug in CORS failure cache for the JavaScript client.
  • Fixed bug in XHR failure handler for the JavaScript client.
  • Fixed bug in JSON-P failure handler for the JavaScript client.
  • Updated message deserialization to handle single-string subscriptions for third-party Bayeux compatibility.
  • Updated examples.
  • Updated documentation.

  • Fixed bug in JavaScript cache buster for IE8.
  • Fixed bug in JavaScript client where exception could be thrown while parsing an invalid response from the server.
  • Fixed bug in JavaScript client where the backoff mode and interval might not initialize properly.
  • Updated JavaScript to support the Microsoft date format when deserializing date objects.

  • Added armv7s support to iOS library and removed armv6 support.
  • Added server libraries specifically targeting .NET 4.0 and .NET 4.5.
  • Added client libraries specifically targeting .NET 4.5.
  • Added cache buster to all JavaScript client requests.
  • Added strong-name signing to all .NET client libraries.
  • Added WebSyncServer.EnableWebSockets/DisableWebSockets/WebSocketsEnabled for .NET 4.5.
  • Removed FM.WebSync.WebSockets library (integrated directly into .NET 4.5 server assemblies).
  • Removed 32-bit support from MacOS library to support ARC.
  • Fixed bug where extensions or provider assemblies might not load at runtime.
  • Fixed bug in client-side WebSocket implementation.
  • Fixed bug in .NET clients whereby a text response might be processed as binary.
  • Fixed bug in server libraries where unsubscribing might not completely unsubscribe.
  • Updated timer in iOS/MacOS to address memory issues.
  • Updated client to fire OnStreamFailure when code in an OnReceive handler throws an exception.
  • Updated documentation.

  • Added new PHP Publisher that uses cURL as an alternative to stream contexts.
  • Added new index to the SQL Server sticky provider to boost performance.
  • Updated Cocoa, Java, and JavaScript clients to fire OnFailure when connecting to a server that failed to initialize properly.
  • Updated documentation.
  • Fixed typo in the disconnect-idle query for the SQL Server stateless provider.

  • Added library for .NET Compact Framework 3.5.
  • Updated client to clear out bound records and subscriptions before stream failure callbacks are executed.
  • Updated invalid server-side method detection.
  • Updated server-side handling of empty requests.
  • Updated server example to demonstrate the use of DefaultResponseHandler.
  • Updated the Azure Caching provider to use custom serialization for a performance boost.
  • Updated the SQL Server sticky provider's handling of dead servers.
  • Fixed bug in the SQL Server stateless provider where new clients could fail to connect.
  • Fixed JSON deserialization bug for empty arrays.

  • Added Extension (Chat, ReturnData, Subscribers) examples for all platforms.
  • Added JsonLite class for mobile platforms that support it (Silverlight, Mono for Android, and MonoTouch).
  • Added JSON validation to Record constructor.
  • Added null-check to array deserialization.
  • Added version info header to JavaScript, iOS, and MacOS client libraries.
  • Replaced SecurityException with Exception for compatibility with Unity 3D.
  • Replaced client-side static Before/After events with Request/Response/Complete events.
  • Updated Subscribers client extension so ClientSubscribe/ClientUnsubscribe events never fire before Success/Failure/Complete.
  • Updated Subscribers client extension to throw an exception if subscribers data is not present.
  • Removed Json class from MonoTouch client library (framework doesn't support it).
  • Fixed MonoTouch examples referencing the DataContractJsonSerializer.
  • Fixed GUID comparison bug in Java, iOS, and MacOS client libraries.
  • Fixed try-cast bug for null values in Java client library.
  • Fixed BinaryWrite bug in WebSync ServiceExample.
  • Fixed bug in WebSync server library where blank GET requests would not return.
  • Documentation updates, including migration guide.

  • Added WebSyncServer.Subscribe/Unsubscribe/Bind/Unbind to allow client state change operations outside an event context.
  • Added setAutoDisconnect method to JavaScript client to support automatic disconnection on page unload.
  • Added DefaultResponseHandler property to WebSyncServer to support a global override of the default response to a blank GET request.
  • Added RequestHeaders property to WebSyncEventArgs to provide consistent access to the request headers regardless of the transport protocol.
  • Updated mega-header file for iOS and Mac OS X libraries so additional headers are not required.
  • Fixed bug in server-side Service and Notify event filter processing.
  • Fixed JSON-P memory leak in Internet Explorer.
  • Fixed thread.sleep bug in JavaScript client.
  • Fixed bug in getSubscribedClients in the subscribers JavaScript extension.
  • Fixed bug in the subscribers server extension when using custom domain keys.
  • Removed intermediary Bayeux classes to improve serialization performance.
  • Removed StreamMode from ConnectArgs - replaced with ConcurrencyMode on Client.
  • Switched to Uglify for JavaScript minification.
  • Various performance improvements on both the client and server (10-15x).

  • Added Tag to client's Service method.
  • Added load testing page to documentation.
  • Added platform considerations section to documentation.
  • Added more examples to documentation.
  • Updated clients to throw exception if handler isn't returned from OnServerSubscribe event.
  • Fixed bug in JavaScript client so allow synchronous behaviour.
  • Fixed "invalid channel" bug in JavaScript client.
  • Renamed Priority to Order in WebSyncEvent attributes.

  • Added native libraries for Mono for Android.
  • Added native libraries for MonoTouch.
  • Added server provider library for Azure Caching.
  • Added server examples for Azure Caching, SQL Server, and services hosted outside IIS.
  • Added Tag to publish/notify methods and receive events to identify the type of payload being sent or received.
  • Added ability to attach multiple handlers to client-level and publisher-level events (breaking change).
  • Split out ReceiveArgs into SubscribeReceiveArgs and NotifyReceiveArgs.
  • Bug fix in JavaScript for adding event handlers.

  • Second beta release.
  • Added WebSyncSecurityAttribute.
  • Many documentation updates.
  • Updated server example project to use VS 2010.
  • Fixed bug where Community edition could not load SQL provider.
  • Fixed bug where clients might not have channels/records accessible in failure args.

  • Initial version 4 release (beta). *