Ashley's Forum Posts

  • Yes, we are working on this and are aiming to have it updated in time.

  • Try Construct 3

    Develop games in your browser. Powerful, performant & highly capable.

    Try Now Construct 3 users don't see these ads

  • IIRC the conclusion last time around was: these are incorrect readings. The app is responding, but Google's services are incorrectly measuring it as not responding. I think it stems from the new splash screen implementation (used by either Cordova or Android, not something specific to Construct) which incorrectly counts the splash screen as the app not responding. Google need to fix the problem in order to make sure the app is counted as responding when the splash is showing and then produce the correct measurements. So for the time being the fact you see a high ANR does not actually mean lots of uses are seeing your app hang.

    FWIW I still think this is weird because even if the splash screen counts as ANR, then the splash screen ought to disappear as soon as Construct shows its loader - which should only take a second or two and not trigger ANR, unless perhaps the device is extremely slow. I'd also advise to make sure the loader style is not "none", because if it is then the splash screen is shown for the full duration the app is loading - if it is any other setting, then the splash screen is hidden as soon as the core Construct engine has loaded and it is able to show its own loader.

  • Construct downloads NW.js automatically for you when you export. Just choose the NW.js export option for your project. See this tutorial for more details.

  • My advice would be: don't increment the variable directly - call a function that increments the variable, and then the function can do other work that needs to be done at the same time as that.

  • Video Recorder supports recording only audio - just choose "None" for the video format. The Voice Recorder example does this.

  • Yes, Construct will always fall back to WebGL if WebGPU is not supported for any reason. If enabled it tries WebGPU first, then falls back to WebGL 2, then falls back to WebGL 1.

  • Support for WebGPU in Construct is a major upgrade involving a great deal of work and some backwards compatibility risk. Therefore support for WebGPU is being rolled out gradually in steps. This forum thread will indicate the current status of support for WebGPU in Construct as it will be evolving over time.

    Background

    For more details about what WebGPU is and what this change means, see these blog posts:

    1. A brief history of graphics on the web and WebGPU
    2. From WebGL to WebGPU in Construct
    3. Introducing Construct's new WebGPU renderer

    Addon developers

    If you are an effect developer you will need to port any existing effects to WGSL to support WebGPU. For more details about this see the Addon SDK documentation on WebGPU shaders.

    Activating WebGPU

    For WebGPU to be used in your project, it must be enabled for all four of:

    1. The chosen preview/export option
    2. The browser engine
    3. The local device's software/hardware
    4. The project settings

    These are described in more detail below.

    Export support

    WebGPU is being enabled separately for individual export options as they become supported. The list below indicates which options WebGPU currently can be enabled on. In the long term we aim to support all platforms.

    • Preview / Remote Preview: supported from r337+
    • Web / Construct Arcade: supported from r345+
    • Android: supported from r380+
    • iOS: supported from r479+
    • Windows WebView2: supported from r345+
    • macOS WKWebView: supported from r479+
    • Facebook Instant Games: not yet supported
    • Playable Ads: not yet supported

    Browser engine support

    WebGPU must also be supported by the underlying browser engine. The list below indicates the current support for WebGPU in browsers. We expect that in the long term, WebGPU support will become as ubiquitous as WebGL.

    • Chrome/Edge (and other Chromium-based browsers/platforms): currently supported in v113+ for Windows, macOS and ChromeOS; Android from v121+; and Linux on Intel GPUs from v144+ (see this issue for further updates on Linux support).
    • Safari/iOS: supported in Safari/iOS v26+. Note however due to a Safari bug WebGPU rendering is glitchy from v26.0-26.3. It should however work correctly from v26.4+.
    • Firefox: currently supported in v141+ on Windows and v147+ on macOS on Apple Silicon devices. Note however a Firefox bug means macOS support only works in v151+. Other platforms are planned but not yet supported.

    Hardware support

    Even with a supported export option on a supported browser/platform, you are not guaranteed to get WebGPU support. This is because it requires relatively modern hardware and software.

    There is not currently any real public documentation on what kind of system requirements there are for WebGPU. However Web3DSurvey.com's WebGPU statistics show a sample of support for a range of platforms indicating how prevalent support is for particular platforms. The main thing to note is if you fulfil all these requirements and still don't get WebGPU support, it may be because your system is not supported; in that case try a newer and more up-to-date system if possible.

    In the Chrome or Edge browsers you can also visit about:gpu to see diagnostic information about the GPU and WebGL and WebGPU support.

    Project settings

    As of r450+, Construct enables WebGPU in your project settings by default. (The default setting for Use WebGPU is Auto, which currently means enabled.)

    If you want to disable WebGPU for a project for any reason, go to the Advanced section of project properties, and set Use WebGPU to No.

    Note that if the project uses any third-party effects, these must have been updated to support WebGPU. Contact the addon developer for support if you need an effect ported to WebGPU.

    Verifying WebGPU is in use

    The easiest way to check that WebGPU is active in your project, meeting all the above support requirements, is to add a Text object to your project and display the PlatformInfo.Renderer expression in it. This will return webgpu when the WebGPU renderer is in use, otherwise it will say webgl1 or webgl2.

    Other ways to check are also:

    • Open Construct's debugger; the second last item in the debugger subtitle includes the same renderer string as the PlatformInfo.Renderer expression, which will also be webgpu if WebGPU is in use.
    • Open the browser console (typically by pressing F12) and look for the console log message indicating Construct's renderer. This should include a line that reads something like "[C3 runtime] Hosted in worker, rendering with WebGPU" if WebGPU is in use; otherwise it will refer to WebGL.

    Editor support

    As of r450+, Construct now also enables WebGPU by default for the Construct editor, where it is used to render the Layout View. This will also use the WGSL variants of effects in the editor. If for any reason you want to go back to using WebGL for the editor, you can do this in Settings by changing Enable WebGPU in editor to No. (Much like the Enable WebGPU project property, this defaults to Auto, which currently means enabled.)

    You can verify WebGPU is in use in the editor by choosing Menu > About > Platform information. If the editor is using WebGPU, then the Platform Information dialog will list WebGPU information instead of WebGL information.

    Issues

    If you run in to any problems when WebGPU is active, please file an issue for them the usual way, including following all the bug report guidelines, and stating that the issue is specific to WebGPU.

    Known issues

    Here is a list of known issues with WebGPU that are currently being tracked.

    • As noted above, Safari 26.0-26.3 support WebGPU, but a Safari bug can make the display look glitchy. It should work correctly with Safari 26+.
    • As noted above, Firefox 147-150 supports WebGPU on macOS, but a Firefox bug prevents using the WebGPU renderer (Construct automatically falls back to using the WebGL renderer). It should work correctly with Firefox 151+.
    • Texture upload performance can be worse than WebGL, causing performance issues particularly with rapidly changing or scaling Text objects. See https://issues.chromium.org/issues/40273077. Possible workarounds are to set the Text object in to fixed resolution mode for faster scaling, or just disable WebGPU and continue using WebGL.
    • See also open Construct issues tagged 'webgpu'

    Conclusion

    WebGPU is a major technology upgrade for both the web and for Construct. We expect to see some significant benefits to supporting WebGPU, including substantially improved performance in some cases. However with major new technologies comes some risk, and so we are taking precautions and rolling out support gradually. Be sure to check back here in future as the support status will be changing over time and this thread will be updated accordingly.

    Tagged:

  • I'm not sure when C3 will support building locally without using your servers, including exporting Cordova projects.

    For the record, Construct has always supported local offline builds.

  • You need more than just the iv to be able to decrypt the data. I added the encrypted binary data format to the Cryptography plugin manual entry which should cover everything you need to interoperate with other code and services.

  • The encrypted data is actually a binary structure which includes some metadata at the start including the iv. But my point in this case, you don't need to worry about any of that, as if you just use HTTPS it's all encrypted anyway.

  • You do not have permission to view this post

  • Custom actions aren't called per-instance in the event system though - an API that matches the way the event system actually works would look more like runtime.objects.Sprite.customActions.MyAction(arrayOfPickedInstances, ...params), but that's not a very natural for a JavaScript API, which is what I meant by the different paradigms.

  • It's sent along with the encrypted data. But you shouldn't need to do that. Use a HTTPS connection and everything you send to the server is already encrypted.

  • Add a Text Input, tick the 'Spell check' property, and the browser will use its built-in spellchecker for whatever is typed in.

  • Construct doesn't provide a script API for the Audio object, but you can just access the Web Audio API directly when using JavaScript code. The concept of tags isn't part of the Web Audio API: it's added by Construct for organising audio in event sheets. Tags aren't really necessary when using JavaScript directly, as you already have full access to the entire Web Audio API.