• Update to WebRTC 120
  • Mac: MacOSX min version is now 10.15
  • iOS: Rebuild with iOS SDK 17.2
  • Android: Rebuild with Android NDK 25 and SDK 34
  • Android: minSdkVersion is now 21 for all architectures
  • Changed setup of the native logger to ensure any errors during init are printed by default
  • WebGL: Added BrowserMediaConfig to give access to more WebGL specific features. See folder scripts/browser
  • WebGL: Selection of an input device is now in testing. Set it by using BrowserMediaConfig.AudioInputDevice and
    (UnityCallFactory.Instance.InternalFactory as Byn.Awrtc.Browser.BrowserCallFactory).GetAudioInputDevices().\
  •  WebGL: Audio is now processed via the Web Audio API allowing audio processing within the Java Script plugin
  • WebGL: Basic support for spatial audio via panning added via new method BrowserWebRtcCall.SetVolumePan
  • WebGL: Improved autoplay block resolution. If a browser blocks audio play it will be resolved once the user interacts
    with the unity Canvas. iOS Safari might block autoplay until several touch interactions are received.


  • WebGL: Fixed an issue with incorrectly setting the bitrate in Safari
  • Android: Fixed a memory leak when shutting down the local camera
  • Minor changes in preparation for the next HoloLens 2 update
  • UWP: Input of ARGB frames is sped up
  • UWP: VideoInput will move images to C++ and convert them in a single step and speed up image processing
  • UWP: UWP: Reduced memory usage and reliance on C# garbage collection
  • UWP: Improved documentation and made sure the xml IDE docs are included
  • HoloVideoChat: Added a very high quality setting but with 15 FPS


  • Updated and Tested with unity 2021 and 2022 LTS. The Unity C# projects will now require the newer Unity versions but the C# API continues to work with Unity 2020
  • MediaConfig.VideoBitrateKbits added to allow setting a target birate (appears to default to 2500 kbits which is too low for HD and higher)
  • MediaConfig.VideoContentHint added. This can be set to motion, detail or text to optimize the video stream for specific content
  • MAINTAIN_RESOLUTION flag is removed. Set VideoContentHint to detail instead
  • MediaConfig.VideoCodecs added. This allows to set a list of codecs to priotize (VP8, VP9, AV1 are usually supported. H264 on iOS and some browsers)
  • RequestStats and RtcStatsEvent added to BrowserWebRtcCall (webgl) and NativeWebRtcCall(all other except UWP). This can be used to check on the current bitrate, used codecs and more
  • Native: NativeMediaConfig.FrameBuffer = true is now the default to help with fluent video playback at low render FPS
  • The VideoInput example scene now shows an animated panorama image to allow testing with different birate requrements
  • WebGL: Calling Unity_Media_EnableScreenCapture(“screen”, true) allows capturing the screen with system audio if supported by the browser.

UWP / Holo Video Chat:

  • Fixed several issues within the wrapper that could cause stalls (deadlock in the SDK) and crashes (leaking of the video tracks that resulted in the camera to remain active)
  • fixed crash causing issue when deactivating EyeTracking. This resulted in the system to restart accessing the camera directly while the VideoTransformer might still access the camera
  • camera access is now delayed by 2 seconds or so
  • Made the log more chatty to hopefully better be able to reproduce any crashes
  • Added different VideoQuality structs to make changing it easier


  • Updated to WebRTC 110
  • From now on, example apps will be saved in Unity 2020. The C# API will continue to work in Unity 2019.
  • Android: min API level should be set to 21 now
  • Logging enhancements: Most logs now include the ownership hierarchy to manage multiple parallel calls
  • Updated all third party dependencies including websocket-sharp and all WebGL npm dependencies
  • awrtc_signaling: updated dependencies and changed the default config to support IPv6
  • Fixed some incorrect namespaces in Byn.Awrtc.Native.dll
  • Native: Major changes in how the audio functions. Let me know if any new bugs show up
  • Native: Added first experimental support for custom AudioInput via the C# wrapper WebRtcCSharp.AudioInput. Example apps will be made available later.
  • Native: Added UnityCallFactory.Config for testing purposes. It will allow turning on global experimental changes such as the new windows audio module
  • Native: Added NativeMediaConfig.FrameBuffer. If set to true this will add a 1 frame long frame buffer to smooth the video frame rate.
  • Native: Added NativeMediaConfig.ReturnLocalVideo. This is true by default and can be set to false to increase performance if access to the local video feed is not required within C#
  • Native: Added PeerFactoryConfig to the native API to allow changing global settings and use multiple factories in parallel in the future
  • Windows: Added support for the newer WebRTC audio module. This can be set via the UnityCallFactory.Config (must be set before the factory is initialized)


  • Deprecated Unity 2018 LTS support. Lowest version is now Unity 2019 LTS for Unity examples. The C# API itself should continue to work with older Unity versions
  • Mac: Update to MacOSX SDK 12.3
  • iOS: Update to iOS SDK 15.5
  • Windows: Switched to Visual Studio Clang build pipeline for x86 and x64 builds. This might change some performance characteristics.
  • Android : Update to NDK 23 and SDK API 31
  • Android: Updated AndroidManifest.xml & build pipeline to work with latest Android versions without generating warnings
  • Android: Due to a security issue in older WebRTC versions the play store with show a warning using the older versions. Please update as soon as possible.
  • Native: Updated native WebRTC library to WebRTC104.
  • Native: Native log level is now correctly set if the asset runs in the Unity Editor
  • Native: Fixed flag MAINTAIN_RESOLUTION in UnityCallFactory. Setting this to true should stop automatic downscaling on all native platforms by setting the content hint to Detail
  • Native: The VideoInput API can now force & change resolutions on the fly via the UpdateFrame method. This can be used to dynamically scale down the video to reduce memory and CPU usage. The Width/Height values in MediaConfig are ignored.
  • Native: The VideoInput API should now support a wider range of framerates and allow changing framerates on the fly
  • Native: Added CommonNetworkConfig.PeerConnectionTimeout. This value allows setting a timeout for establishing the direct peer to peer connection
  • WebGL: Fixed log levels being set incorrectly for the JavaScript side backend
  • WebGL: TextureFrame and FrameProcessor have been updated to reduce the risk of memory leaks if a frame is not used e.g. due to Exceptions in user code. IFrame.Dispose must still be called though!
  • WebGL: updated third party dependencies
  • WebGL: Using the webrtc-adapter to help with cross browser compatibility can now be deactivated.
  • WebGL: Errors during video/audio device configuration are now correctly moved from JavaScript to C#
  • UnityCallFactory will now warn and automatically set Application.runInBackground=true if not done so by the app developer


  • Examples: Signaling & TURN server urls have been updated
  • CallApp: CallApp will now always use secure websockets by default
  • CallApp: The app now uses the new FrameProcessor to convert platform specific formats into Unity Texture2D. Using I420p can reduced CPU overhead by moving some conversion to the GPU.
  • New MediaConfig default values: sending Video and Audio is now off by default
  • Improved logging. ICall/IMediaNetwork and peers now have a global ID to allow associating log messages with individual instances. Log messages are prefixed with “awrtc:”
  • log level can now be set via SetLogLevel/SetNativeLogLevel
  • Fixed misleading warning log & issue with dropping signaling messages that arrive after a call already successfully connects
  • Removed various obsolete classes & method
  • Improved error messages given by UnityCallFactory & websockets
  • Removed .NET 3.5 backwards compatibility
  • Added NetworkConfig.KeepSignalingAlive to keep the signaling connection active
  • KeepSignalingAlive and IsConference=true now allows custom server side code to start & shutdown client side peers by connecting/disconnecting a signaling connection.
  • ConnectionId’s for signaling and MediaNetwork connectionIds are the same now
  • VideoInput: Shared API added for all supported platforms including WebGL
  • VideoInput: Added information for use with HDR
  • Native: CommonNetworkConfig can now be used to create Calls/MediaNetwork instances with custom signaling network / custom websocket timeouts
  • Native: Several old create methods removed from the factory classes. Use the create methods that get NetworkConfig as argument instead.
  • Native: Added codec settings in NativeMediaConfig(experimental) to priotize codecs or change other codec specific settings
  • Native: NativeMediaConfig.AudioAccess (experimental): Can be used to request emiting AudioFrame events with raw PCM for each incoming connection
  • Native: Proxy support added (experimental)
  • WebGL: Added support for Screen Capture API. Enabled via Unity_Media_EnableScreenCapture(“Screen capture”)
  • WebGL: Fixed memory leak if multiple streams are active in parallel that use the “Native” pixel format.
  • WebGL: updated npm dependencies
  • Android x64 support added
  • Android: Removed all WebCamTexture references to ensure Unity does not automatically add the Camera permission if it is removed from the AndroidManifest.xml
  • Android: Fixed a bug causing log message to be truncated
  • Android: added proguard-user.txt with rules to ensure proguard doesn’t strip required java components
  • iOS: Added workaround for hardware decoding issues with resolutions greater than 720p
  • awrtc_borwser (experimental): Added an alternative peer configuration enabled via SINGLE_NEGOTIATION=true. It will allow setting up the peer for video & audio but allows enabling/disabling these without renegotiation
  • ConferenceApp: Added randomly generated usernames to show how ICall.Send can be used to tell different users apart and keep a reference between username & ConnectionId
  • Ice Restart (experimental) NetworkConfig.MaxIceRestart can be set to allow several reconnection attempts before a connection is treated as disconnected.
  • Reconfigure (experimental): ICall/IMediaNetwork.Configure can now be called at run-time to change settings without reconnecting. This requires an active signaling connection (KeepSignalingAlive=true).


  • WebRTC 93
  • Several performance improvements & bugfixes related to image delivery
  • Fixed issue with Unity 2021.2 WebGL builds
  • AudioAccess (Experimental): NativeMediaConfig.AudioAccess = true can be used to get access to the raw audio data. This is returned via AudioFrameEventArgs.
  • iOS: Built using the iOS 15 SDK
  • iOS: Change min iOS version is now iOS 12 & arm 32 bit devices are not supported anymore
  • Native: I420p frames can now be processed faster and can be stored within a single texture
  • CallApp: ImgFitter will now work directly if placed on a world space canvas in 3D and can handle I420p single buffer frames
  • Minor bugfixes related to use with VR & AR libraries
  • Fixed issue of default video device not working if VideoDeviceName is set to null or “”


  • WebRTC 90
  • M1 Mac support added via universal binary
  • General cleanup and removal of obsolete classes / methods
  • Fixed crash if invalid signaling messages are received
  • CallApp example should now also work with canvas located in 3D world space
  • VideoInput: example to automatically turn off async readback if not supported on the current platform / render API
  • VideoInput: VideoType renamed to ImageFormat
  • Android: Upgrade to SDK 29
  • Mac / iOS: XCode 12.5 & iOS SDK 14
  • WebGL: Fixed issues with video on iPhone Safari
  • WebGL: updated all third party dependencies


  • Native: Major WebRTC upgrade to m87
  • Native: complete rewrite of platform specific video device access & VideoInput
    This might lead to a change in performance and some minor changes in behaviour.
  • Max / Min Width & Height values are now ignored on most platforms & browsers
  •  added a few tests for android hw acceleration
  • VideoInput example has been optimized for better performance & a more complex demo scene has been added for testing
  • WebGL: VideoInput support added
  • WebGL: Sending video from the unity canvas or other elements in the webpage has been added (see VideoInput example)
  • Native: Added i420p support. This needs a custom shader before showing to the user.
  • Native: Fixed native log flag
  • CallApp: Added a new UI element to select the image format (if possible)
  • WebGL: added support for “Native” image format. By using this format image data is moved directly from
    HTML Video Element into a WebGL texture avoiding the copy form JS to Unity C# and increasing performance
  • Removed old flag to keep iOS audio module active. This is not needed anymore.
  • Updated native AudioOptions to reflect changes in the native WebRTC version. The “echo_cancellation” flag should work reliably now
  • Added NativeMediaConfig.UseDataChannels to allow deactivating the data channels to help with SFU support (experimental)
  • WebGL: Added a workaround for Safari autoplay issues. Safari will still block playback but it will resume
    after an onclick / tab event is received
  • Updated a few examples to make them more interactive for better testing
  • WebGL: The WebGL plugin is now stored as a txt file and loaded via eval to allow using newer JS features than supported in jspre files
  • Updated examples to work with newer Unity versions without warnings. Asset remains backwards compatible to 2018LTS
  • iOS: h264 hw encoder / decoder can now be deactivated via a flag in the UnityCallFactory


  • Info.plist had windows line endings instead of mac causing the mac plugin to report a security error
  • This is an asset store update only. Binary version remains at 0.9845


  • Unity 2018.4.22f1
  • WebGL: fix for Chrome 81 issues. Chrome 81 returns an invalid device ID if the user didn’t allow camera access yet. This could result in an overconstrained error
  • WebGL: fixed issue that could cause some users not to disconnect correctly  for conference calls
  • Native: fixed an issue that can cause a connection to fail randomly even on a stable network
  • Android: fixed an issue that could cause a crash randomly if the call is shutting down while the local camera was active
  • Android: fixed an issue that could cause a delay in remote video playback
  • iOS: Improved build pipeline to better support several Unity versions & better error messages
  • Mac: signed & notarised + updated Info.plist for app store releases
  • Cleanup log output
  • Example apps are updated to use EnsureInit to allow them to run in WebGL without changes
  • CallApp: the app will now keep the chat panel open if the call ends
  • CallApp: fixed an issue that could make it difficult to shut down the app if the rejoin option is active & the system is offline


  • iOS workaround: Unity audio can stop playing on iOS 13 after a call ends. To avoid this the WebRTC audio layer will remain active now. You can revert to the default behavior by removing line “WebRtcCSharp.IosHelper.IosKeepAudioActive(true);” in UnityCallFactory. If the unity audio stops playing it can also be restarted it by calling the native C call “UnitySetAudioSessionActive”
  • Merged all previous hotfixes into this version
  • VirtualCamera will now use a depth buffer
  • Android: CallAppUi will now individually request Microphone or Camera permissions if the Audio or Video button is pressed. It will untick it automatically if the permissions are missing. Some unity version omitted the second permission request if both were triggered at the same time
  • CallApp: Updated UI to be more reliable for different resolutions (should remain compatible to Unity 2017 prefab format)
  • Native plugins: Rebuild using new compiler versions
  • Removed some warnings that showed up if specific platforms were selected
  • WebGL: Newer Chrome versions stopped triggering the state ice failure that was used to detect a remote disconnect. It will use the state “disconnected” now
  • Patch1: signed & notarised for macos Catalina
  • Patch2: Updated iOS build script for Unity 2019.3


  • rebuild for the win x86 version to avoid an apparent compiler bug that could cause crashes during encoding of VP8 frames . Only specific CPU’s with AVX support were effected. The returned version remains at 0.9841 as no other platforms were effected.


  • iOS hotfix: In iOS 13 the local video could fail to show up / being sent. The new iOS version changed the video format by adding a padding at the end of each row of pixels causing a 1280×720 image to be 1280×768 in memory. The new hotfix will remove this padding and make sure the C# side remains compatible to all earlier versions.
  • The built-in version number will still be “V0.9841” only the asset store version number had to be increased to “V0.9842” to trigger the update + notification


  • revert CallApp.prefab to restore Unity 2017 compatibility for now
  • Android: Fixed bug that caused the video stream not being sent if MediaNetwork.TryGetFrame wasn’t called or ICall.LocalFrameEvents wasn’t set
  • Android: Updated the CallApp & Conference examples to reliably trigger camera & microphone permission with newer Unity versions
  • Windows: Fixed bug that prevent microphone access / audio being sent to the remote side if native echo cancellation was supported by the device and the device did not receive any audio while sending


  • iOS build with Xcode 10.1 and iPhoneOS12.1 for arm & arm64
  • Android build armeabi-v7a, arm64-v8a, x86 using ndk-r16b and sdk 28, jdk 1.8 (requires JavaVersion.VERSION_1_8)
  • WebRTC’s Unified plan is now used by default. For now you can turn this off on native platforms via Byn.Awrtc.Native.InternalDataPeer.
  • ICall can return more accurate error information via ErrorEventArgs.Info
  • Property NetworkEvent.ErrorInfo added to return error information for some events e.g. ConnectionFailed. More detailed information + fixed error codes will be added to this later.
  • CallApp update: Changed the UI to work with world canvas in VR applications (Samsung Gear VR / Oculus example coming soon)
  • Added GetBufferedAmount to native & WebGL
  • WebGL: added an error message to show when autoplay restrictions block playback. This situation can’t be handled by the asset itself yet.
  • WebGL: Support for async init to have video devices available from the first frame
  • WebGL: updated to better work with recent Chrome changes and if loaded via http / file: url’s (mediaDevices null)
  • WebGL: Will fail now during init some WebRTC features aren’t available to avoid cryptic error messages during runtime
  • Android: The callapp will request android permissions to access Audio / Video devices as required for Unity 2018.3 and higher
  • Added support for custom signaling systems
  • All platforms send out a heartbeat every 30 seconds while connected to the signaling server. Disconnects will be detected after around 15-30 seconds instead of relying on Websocket timeout detection
  • signaling server: flag log_verbose allows to turn off most log messages via the config.json. This can increase connection speed!
  • signaling server: dependencies have been updated due to security issues. Make sure to keep your server up-to-date
  • signaling server V0.984: Update signaling server and protocol to support heartbeat & different protocol versions. Old servers still work but will report protocol errors due to the new messages! Update to V0.984 if clients are updated
  • Native platforms: Removed old obsolete “RTC” classes.
  • MaxOSX +  Windows: Added support for two devices that have the exact same name. The asset will add numbers to the name and uses ID’s to internally address them
  • Windows: Fixed a crash that could happen if another system accessed a video device before the asset without releasing the handle
  • Updated to Unity 2018.4 LTS
  • upgrade to WebRTC 72
  • Added Android arm64 support (arm64-v8a)
  • New video system is work in progress at the moment. The new version has a “_” prefix for device names


  • Breaking change:  WebRTC Network and Video have been merged. The namespace Byn.Awrtc contains all public classes now that were previously in Byn.Net, Byn.Media, Byn.Common.  Updating your using commands to Byn.Awrtc should fix most compiling errors you might encounter
  • Merged most C# assemblies
  • Started supporting asynchronous init. Use UnityCallFactory.EnsureInit(OnCallFactoryReady, OnCallFactoryFailed) to allow the underlying platform to initialize asynchronous. This will be required for some platforms in the future (UWP and possibly WebGL)
  •  WebGL:
    • using adapter.js now to support a wider range of browser versions
    • allows listing and selecting video devices
    • Workaround for Firefox specific bug that could cause the local video not to show up
    • Plugin is now built delivers as jspre plugin file and is using Webpack + modules to keep the use of global variables to a minimum. It is exposed via window.awrtc
    • Updated WebRTC API calls to the modern specification / avoid browser warnings
    • Added support for min,max and ideal FPS constraints for local video devices
  • Browser version: A full browser version is now available that can connect to all other platforms and provides a similar API
  • iOS:
    • fixed an error in the plist file that caused the app store to remove armv7 support
    • added H264 support
  • Android
    • Improved AndroidHelper
  • Mobile: UnityCallFactory.Instance.IsFrontFacing  / UnityCallFactory.Instance. GetDefaultVideoDevice added to make it easier to pick the front facing video device
  • The asset is using asmdef files now
  • Added detailed license information for third party libraries (see license_third_party.txt and license_webrtc.txt)
  • Two new purchasable features are now available: Latest development version for UWP/HoloLens and dwrtc (a direct wrapper to access WebRTC). Please inquire by email for more detail.


– Removed obsolete wrapper methods. Recent changes in WebRTC broke most of them
– Update to WebRTC 64 + switching to newer compiler versions (XCode 9, VS 2017, newer NDK)
– Cleanup of log calls
– ICall.SetMute / IsMute added to silence the local microphone on all platforms
– Added mute button in the CallApp
– added bool Send(string, bool, ConnectionId) to ICall and IBasicNetwork to support high throughput data transfer
– Rework of the frame delivery system. RawFrame is obsolete and will be replaced with IFrame (will be completed in V0.983)
– for testing: some platforms can deliver frames in i420p which reduces CPU load (see SimpleCall example)
– Added first changes to support direct access to some WebRTC functionality in the future
– Android supports native video now (camera 1 or camera 2 API depending on the device). The old camera system is deactivated by default.
– added AndroidHelper.IsFrontFacing / IsBackFacing. For all platforms WebcamTexture can be used for this.
– Android native plugin is bundled into an .aar file now. Unity will automatically include necessary changes for the AndroidManifest.xml
– Android comes with a java plugin now to support platform specific features in the future
– Android IL2CPP support has been added
– iOS plenty of bugfixes and performance improvements
– iOS comes with an Objective C plugin now to support platform specific features in the future
– WebGL version updated to use newer API calls
– WebGL fixed several bugs related to various image resolutions / rotated images received from mobile phones
– Bugfix: using invalid device names could cause crashes on some platforms
– Bugfix: Video shouldn’t stop anymore if the scene is changed on Android
– Bugfix: Fixed problems with the loud speaker mode for iOS device
– Bugfix: multi-threading issues / stalling on shutdown or startup


– Documentation updated. Please visit to find out more
– Tutorials for signaling server & stun/turn server setup added:
– ICall received new methods to send String & byte[] to one or multiple users using UDP or TCP style channels
– Android video has been further optimized (full native camera access will come soon)
– CallApp has a new configuration button allowing users to change resolution and other settings
– CallApp shows now additional information if the image is clicked once
– CallApp will now save the last settings (based on the name if its GameObject to still allow multiple instances in one application)
– extra folder added. These are additional features requested by users and can be used at your own risk.
– extra VideoInput added. It can be used to stream custom images or from a Unity camera
– mobile devices won’t switch off screen any more of CallApp is used
– extra OneToMany added. It is an example how to use the IMediaInterface to stream to multiple recives.
– extra VideoConference added. An example how to create conference calls using ICall interface.
– example folder added. It contains several minimal examples to help new users.
See more here:
– mac native libraries uses proper bundle format now
– iOS workaround added. If a phone call ends Unity will turn off sound for all
AudioSources. IosHelper.UnitySetAudioSessionActive can be called after the call ended to switch
the Audio back into the correct mode. All AudioSources need to be restarted after it.
– signaling server contains now a webserver to make testing and use of easier


– iOS support (arm + arm64). Please check the readme.txt for how to build it.
– Removed log messages / errors appearing with Unity 2017.2
– C++ side was rewritten entirely replacing all callbacks with a polling based system
– Using the debugger in Unity should work better now
– Video Frames will now be automatically dropped if the Update method isn’t called quickly enough (e.g. during a FPS drop)
– IMediaNetwork is now supported and can be created using UnityCallFactory.Instance.CreateMediaNetwork
It works similar to WebRTC Network’s IBasicNetwork interface but adds audio and video to make broadcasting to
audio / video to multiple users easier
– UnityCallFactory.SetLoudspeakerStatus / GetLoudspeakerStatus added. Mobile devices treat WebRTC calls like regular phone calls
requring the speakers to be manually turned on.
– WebGL version was adapted to recent changes in Chrome. The CallEnded event should now be triggered during disconnects due to network failure
– CallApp was improved to better support mobile platforms + a new button was added to change SetLoudspeakerStatus
– Numerous smaller bugfixes and changes based on user reports received in the past few months


– WebGL and native ICall and IMediaInterface supports now new methods: SetVolume, HasVideoTrack, HasAudioTrack
– Android x86 is now supported
– Updated AndroidHelper.cs. It now includes functions to change volume or switch to IN_COMMUNICATION mode
(to allow the user to change the volume via the volume keys)
– Works with Unity 5.6 WebGL now
– Update to WebRTC 56


– Android version heavily optimizes + improvement in documentation (check readme.txt !!!)
– added Echo cancellation support for native applications (see CallApp.Start())


– UI improvement in CallApp
– Stun / Turn servers are now fully supported including username / password for login
– Bugfixes for Android
– Video support for Android and Mac via Unity video texture


– Update WebRTC version to the same as Chrome 53
– Stun server and signaling server can be changed in prefabs
– Bugfixes


– Added support for Android and OSX (video support is not yet stable!)


– Added support for broadcast / multicast networks (configured at server side))
– New events ConfigurationComplete and ConfigurationFailed triggered by ICall.Configure calls
– Video Conferences are now supported! Activate it using the NetworkConfig.IsConference flag.
Conference Call example app follows soon!
– The resolution of the local webcam can be changed now (see class MediaConfig)
– Added support for WebGL
– some optimization / increase in performance


– Initial release