Following Monday's announcement of OpenGL ES 3.1, Khronos today announced the specifications for WebCL 1.0 -- that let Web apps tap into GPU -- EGL 1.5 and SYCL 1.2.

Developed in cooperation with the Web community, WebCL extends the capabilities of HTML5 browsers by enabling developers to offload computationally intensive processing to available computational resources such as multicore CPUs and GPUs. WebCL defines JavaScript bindings to OpenCL APIs that enable Web applications to compile OpenCL C kernels and manage their parallel execution. Like WebGL, WebCL is expected to enable a JavaScript middleware that provides access to accelerated functionality to a wide diversity of Web developers.

WebCL 1.0 supports OpenCL 1.1 Embedded Profile functionality and can also be layered over any conformant OpenCL 1.1 or OpenCL 1.2 implementation. The final WebCL 1.0 specification are available for immediate download at: https://www.khronos.org/webcl.

WebCL 1.0 features and utilities include:

• Standardized, portable and efficient access to heterogeneous multicore computing in the browser, through JavaScript bindings to OpenCL;
• Architected and designed for security using multiple techniques including: leveraging OpenCL security extensions for memory initialization and context termination, and an open source WebCL Validator to enforce security protections, to prevent out of bounds memory accesses and to enforce memory initialization;
• Interoperability between WebCL and WebGL, through a defined WebCL extension, to enable Web applications to employ accelerated graphics and compute for rich visual computing applications within the browser;
• An open source OpenCL to WebCL Kernel Translator to enable rapid porting of native OpenCL applications to WebCL.

The WebCL 1.0 specification is the result of feedback from the Web community based on the public working draft and the Khronos WebCL Working Group, including; Adobe, AMD, Aptina, ARM, Google, Imagination Technologies, Mozilla, Intel, Nokia, NVIDIA, Opera Software, Samsung, and Qualcomm.

The second set of specifications released today by the Khronos Group is the SYCL 1.2. SYCL is a royalty-free, cross-platform abstraction layer that enables the development of applications and frameworks that build on the underlying concepts, portability and efficiency of OpenCL, while adding the flexibility of C++. For example, SYCL can provide single source development where C++ template functions can contain both host and device code to construct complex algorithms that use OpenCL acceleration - and then enable re-use of those templates throughout the source code of an application to operate on different types of data.

The SYCL 1.2 provisional specification supports OpenCL 1.2 and has been released to enable the community of OpenCL developers to provide feedback before the specification is finalized.

"Developers have been requesting C++ for OpenCL to help them build large applications quickly and efficiently and there are lots of useful C++ libraries that want to port to OpenCL," said Andrew Richards, CEO at Codeplay and chair of the SYCL working group. "SYCL makes this possible and we are looking forward to the community feedback to help drive the final release and future roadmap. We are especially keen to work with C++ library developers who want to accelerate their libraries using the performance of OpenCL devices."

SYCL 1.2 features include:

• API specifications for creating C++ template libraries and compilers using the C++11 standard;
• Easy to use, production grade API that can be built on-top of OpenCL and SPIR;
• Compatible with standard CPU C++ compilers across multiple platforms, as well as enabling new SYCL-based device compilers to target OpenCL devices;
• Asynchronous, low-level access to OpenCL features for high performance and low-latency - while retaining ease of use;
  
• Khronos open royalty-free standard - to guarantee ongoing support and reciprocal IP coverage;
• OpenGL Integration to enable sharing of image and textures with SYCL as well as OpenCL;
• Development in parallel with OpenCL ? future releases are expected to support upcoming OpenCL 2.0 implementations and track future OpenCL releases.

The EGL 1.5 specification. EGL is a royalty-free standard that defines a portable interface to underlying operating system and display platforms to handle graphics context management, surface and buffer binding, and rendering synchronization. EGL also provides interop capability to enable efficient transfer of data and events between Khronos APIs. The new EGL 1.5 specification incorporates functionality for enhanced rendering flexibility and security, improved interop between OpenGL or OpenGL ES and OpenCL for mixed compute and rendering acceleration, and standardized support for multiple common operating systems including Android and 64-bit platforms. The EGL 1.5 specification, header files and links to feedback forums are available at: www.khronos.org/egl.

GL 1.5 Features

• EGLImage objects as core functionality. EGLImages are already widely supported through optional extensions and provide flexibility to graphics applications by enabling sharing of OpenGL and OpenGL ES textures and renderbuffers between contexts;
• Support that places restrictions on the creation of a graphics context to prevent malicious usage, especially important for secure WebGL implementations;
• Enhanced support for 64-bit platforms by avoiding size-dependence in APIs taking pointers, enabling standardized usage of EGL on both 32-bit and 64-bit operating systems;
• EGL Platform extensions for Android, GBM, Wayland and X11 to cleanly define how each platform/OS interacts with EGL to enable a single EGL implementation to dynamically support multiple windowing systems;
• Enhanced OpenCL interop through the creation of EGLSync objects from OpenCL events to enable synchronization between OpenGL and OpenGL ES commands and OpenCL command queues, minimizing or even avoiding CPU involvement when synchronizing GPU work performed in different APIs;
• EGL fence sync objects as core functionality to provide the ability to insert fences in client API command streams (e.g. OpenGL or OpenGL ES), which can then be used to synchronize with the user process at a tighter granularity than APIs like glFinish (client-side waiting), or between command streams without any user process involvement (server-side waiting);
• EGLContext improvements that enable making a context current without association to a surface, and simplifying how applications that only want to render to client API targets (such as OpenGL framebuffer objects) obtain contexts;
• Support for sRGB colorspace rendering in OpenGL ES, using a standard defined color space and simplifying support for gamma-correct blending and scaling;
• Control of graphics reset notification behavior, allowing applications to detect a graphics reset through an inexpensive query.