Categories
-
+
All
diff --git a/_layouts/default.html b/_layouts/default.html
index cbf61f4dbe..79720f5ffd 100644
--- a/_layouts/default.html
+++ b/_layouts/default.html
@@ -21,7 +21,7 @@
-
+
diff --git a/_layouts/download-3.html b/_layouts/download-3.html
index 30b19af48c..fe646926f3 100644
--- a/_layouts/download-3.html
+++ b/_layouts/download-3.html
@@ -6,7 +6,7 @@ layout: default
{% include header.html %}
-
+
-
👋 See you there!
\ No newline at end of file
+
👋 See you there!
diff --git a/collections/_article/gdc-2024-retrospective.md b/collections/_article/gdc-2024-retrospective.md
index 0e08200896..75193d2e4a 100644
--- a/collections/_article/gdc-2024-retrospective.md
+++ b/collections/_article/gdc-2024-retrospective.md
@@ -2,7 +2,7 @@
title: "GDC 2024: Retrospective"
excerpt: "We have returned from the Game Developers Conference (GDC) in San Francisco, so let's talk about it!"
categories: ["events"]
-author: Nathalie Galla
+author: Nat
image: /storage/blog/covers/gdc-2024-retrospective.jpg
date: 2024-04-05 14:00:00
---
@@ -15,7 +15,7 @@ First of all, we want to thank our sponsors at W4 Games again for providing us w
The main difference to last year is rather shocking: barely anyone needed an explanation about what Godot is anymore. Visitors were excited to play the [showcased games](https://godotengine.org/article/gdc-2024-godot-games/), and recognized titles — some really surprised to find out their favorites used the engine! Studios and other companies also came by plenty to talk about how they found out about Godot through an excited colleague or the news, and a handful mentioned they started experimenting or even using it in their projects. We took note of people’s wants & needs during these chats, appreciative of being able to forward these first hand accounts of users directly to our engineers.
-Notably, we heard from a significant number of people who recently transitioned to Godot that it is working well for them, they love the current feature set, and the engine is not holding them back. However, they are still encountering a few too many pain points requiring workarounds or waiting for updates. For the team, this was a strong indicator that we need to spend more time identifying and resolving these everyday “papercut” issues that add up and impact users' workflows. Expect to hear more about this soon, as we are back to discuss and adapt our priorities to the feedback we brought with us from the conference.
+Notably, we heard from a significant number of people who recently transitioned to Godot that it is working well for them, they love the current feature set, and the engine is not holding them back. However, they are still encountering a few too many pain points requiring workarounds or waiting for updates. For the team, this was a strong indicator that we need to spend more time identifying and resolving these everyday “papercut” issues that add up and impact users' workflows. Expect to hear more about this soon, as we are back to discuss and adapt our priorities to the feedback we brought with us from the conference.
@@ -29,7 +29,6 @@ Our gathering at GitHub HQ also proved successful, with many Godot users, conten
As for the team itself, this conference allowed the fully remote team to assemble in person again. Between booth duty, team meetings, and extracurricular activities, we are happy to report we all grew a little closer. Even engine developers need to leave their houses sometimes ;)
-At the end of the day, we and everyone we met are passionate about this open source project — interacting with the community in person is a really helpful tool to remind everyone of that common ground, and use it to our advantage: to compare feedback and sentiment to what we hear on the internet, and to forge lasting relationships. Which is one of the key reasons why we are now looking into being present at more conferences across the world in the future, aiming to enable more of these important conversations and super helpful learnings. This will come at the expense of a smaller GDC booth next year however, as we have to split budget and personpower accordingly. San Francisco indeed proved as pricey as everybody keeps saying, and we strongly believe there is more to gain from diversifying opposite to always being in one and the same location.
+At the end of the day, we and everyone we met are passionate about this open source project — interacting with the community in person is a really helpful tool to remind everyone of that common ground, and use it to our advantage: to compare feedback and sentiment to what we hear on the internet, and to forge lasting relationships. Which is one of the key reasons why we are now looking into being present at more conferences across the world in the future, aiming to enable more of these important conversations and super helpful learnings. This will come at the expense of a smaller GDC booth next year however, as we have to split budget and personpower accordingly. San Francisco indeed proved as pricey as everybody keeps saying, and we strongly believe there is more to gain from diversifying opposite to always being in one and the same location.
Did you visit the booth? Snapped any pictures you want to share with us? Use the forum post [linked here](https://forum.godotengine.org/t/gdc-2024-retrospective/54687) to tell us about your experience at GDC, we would love to hear back from you :)
-
diff --git a/collections/_article/gles2-renderer-optimization-2d-batching.md b/collections/_article/gles2-renderer-optimization-2d-batching.md
index fc1b8b6c3f..1db550f596 100644
--- a/collections/_article/gles2-renderer-optimization-2d-batching.md
+++ b/collections/_article/gles2-renderer-optimization-2d-batching.md
@@ -2,7 +2,7 @@
title: "GLES2 renderer optimization - 2D batching"
excerpt: "While Juan's work on the Vulkan rendering backend is ongoing in the master branch, the rest of the rendering team have not been idle. They have been working on many bug fixes and some improvements to the OpenGL rendering in the 3.x branch, and one of the most awaited is the addition of batching of 2D primitives in the GLES2 renderer, which should significantly increase performance in a lot of 2D games."
categories: ["progress-report"]
-author: Bartleby Lawnjelly
+author: lawnjelly
image: /storage/app/uploads/public/5e8/e58/0c6/5e8e580c63d1e981395802.png
date: 2020-04-09 11:42:21
---
diff --git a/collections/_article/godot-community-poll-2024.md b/collections/_article/godot-community-poll-2024.md
new file mode 100644
index 0000000000..a1735c41db
--- /dev/null
+++ b/collections/_article/godot-community-poll-2024.md
@@ -0,0 +1,24 @@
+---
+title: "Godot Community Poll 2024"
+excerpt: "We want to learn more about the Godot community, understand who the users of the engine are, and find out how we can better support you."
+categories: ["news"]
+author: Emi
+image: /storage/blog/covers/community-poll-2024.webp
+image_caption_description: Illustration by André Marí Coppola
+date: 2024-06-28 14:00:00
+---
+
+**Update:** This poll is now over. [You can view the results here.](https://docs.google.com/forms/d/1eicOppRQG2RFZ8CjIGFf5Kha5yklO854fV8-YFtlWxk/viewanalytics)
+
+___
+
+
+We want to learn more about the Godot community, understand who the users of the engine are, and find out how we can better support you. We have a short list of questions and hope you will take a few minutes to fill them out.
+
+The poll is anonymous, and we will share the results publicly once submissions are closed. It will remain open for a week and should take only 5-10 minutes to complete.
+
+👉 [Click here to complete the 2024 community poll!](https://forms.gle/tkxaJr72qt2U52SY8)
+
+If you are interested in results from previous years, you can find them at the following links:
+[2023](https://docs.google.com/forms/d/e/1FAIpQLSeXRE1nF64PUilO6fA7Pevh2lWukJtpdBvc2_A3fGfuciy-gQ/viewanalytics),
+[2022](https://docs.google.com/forms/d/e/1FAIpQLSe-OIpxXqou9cDnPXEAjxzpICbf8_YZB3jUizdECXRydtB8cA/viewanalytics), [2021](https://docs.google.com/forms/d/e/1FAIpQLSfOj9m71X98_z7-UC4iiM6Uxd2HhITRzmF-M2Yx-d7Yq5KNUg/viewanalytics), and [2020](https://docs.google.com/forms/d/e/1FAIpQLSePCblF1p-Sv3AJYWQ8reRhx8c-1WOX9ZI0P-NJ-5TGw79bqA/viewanalytics).
diff --git a/collections/_article/godotcon-2024.md b/collections/_article/godotcon-2024.md
new file mode 100644
index 0000000000..e99a84bbeb
--- /dev/null
+++ b/collections/_article/godotcon-2024.md
@@ -0,0 +1,33 @@
+---
+title: "GodotCon 24 - Submit ideas! Get tickets!"
+excerpt: "GodotCon 24 will take place on the 12+13th of October in Berlin, Germany. The first batch of tickets as well as the call for speakers and exhibitors just went live. Sponsors welcome."
+categories: ["events"]
+author: Nat
+image: /storage/blog/covers/godotcon-2024.webp
+date: 2024-06-14 18:00:00
+---
+
+| 📅 Date | 12th+13th of October |
+| 📍 Location | Berlin, Germany |
+| 🌐 Website | https://conference.godotengine.org/ |
+
+After a very successful conference last year in Munich, we onboarded more lovely volunteers and expanded our offerings: this edition will have talks, workshops, a game/project showcase, and downtime activities around the venue.
+
+The event grounds we chose offer ample space to simply sit and chat, especially if the weather permits using the outdoor spaces. Scattered across the floors you will also have the option to buy food & drink. We will definitely also use the opportunity to sell limited edition Godot merchandise.
+
+To facilitate business meetings, we are currently setting up our own matchmaking software; stay tuned to learn more about it. It will be available for all attendees, no matter the ticket choice.
+
+Have you thought about participating in the program yet? Take a look at our call for speakers and exhibitors below - this event is a collaborative effort between us and the community!
+
+[**➡️ Call for submissions**](https://talks.godotengine.org/godotcon-24/cfp), Deadline: 31st of July
+
+Speaking of collaboration, we are actively looking for sponsors to support GodotCon not just monetarily, but also with content or products. If you or your company would be interested in learning more about the sponsorship ideas we have prepared, simply download this fact-sheet we put together and reach out to [godotcon@godotengine.org](mailto:godotcon@godotengine.org).
+
+[**⬇️ Sponsor factsheet**](https://conference.godotengine.org/downloads/godotcon24-factsheet-sponsoring.pdf)
+
+Last but not least, as we collectively gear up to make this event a blast, people already have been gathering on our community Discord to share their excitement and reminisce about the past years together.
+Even if you do not plan to attend this installment, we recommend taking a look for potential business contacts and to be the first to know about any future events.
+
+[**➡️ Join the GodotCon Discord**](https://discord.gg/nAcE7msd5H)
+
+See you in autumnal, pumpkin-spice smelling, hopefully not too cold Berlin! 🍂🥧
\ No newline at end of file
diff --git a/collections/_article/introducing-reverse-z.md b/collections/_article/introducing-reverse-z.md
index f702d827d0..df468f8839 100644
--- a/collections/_article/introducing-reverse-z.md
+++ b/collections/_article/introducing-reverse-z.md
@@ -62,8 +62,8 @@ Writing to `DEPTH` comes with the same warnings as writing to `POSITION`. If the
```
// This will continue to work.
vec4 clip_pos = PROJECTION_MATRIX * vec4(VERTEX, 1.0);
-clip_space.xyz /= clip_space.w;
-DEPTH = clip_space.z;
+clip_pos.xyz /= clip_pos.w;
+DEPTH = clip_pos.z;
// This will need to change.
DEPTH = 0.0; // Needs to change to 1.0.
@@ -91,7 +91,7 @@ This code will require no modification. Where users will need to make modificati
```
vec4 clip_pos = PROJECTION_MATRIX * vec4(VERTEX, 1.0);
-clip_space.xyz /= clip_space.w;
+clip_pos.xyz /= clip_pos.w;
float depth = textureLod(depth_texture, SCREEN_UV, 0.0).r;
if (clip_pos > depth) {
diff --git a/collections/_article/january-jams-2024.md b/collections/_article/january-jams-2024.md
index e748a451f7..dfdde42e54 100644
--- a/collections/_article/january-jams-2024.md
+++ b/collections/_article/january-jams-2024.md
@@ -2,7 +2,7 @@
title: "January Jams"
excerpt: "Looking back at a month of game jams, we curated a list of ten events that you might or might not have heard of before."
categories: ["events"]
-author: Nathalie Galla
+author: Nat
image: /storage/blog/covers/godot-jam.webp
image_caption_description: "Jam base image by
luis_molinero on Freepik"
date: 2024-01-31 12:00:00
@@ -22,7 +22,7 @@ Did you hear about Mickey Mouse entering the public domain this year? How is tha
### 2. Finally Finish Something (FFS) 2024
-🔗 [https://itch.io/jam/finally-finish-something-2024](https://itch.io/jam/finally-finish-something-2024)
+🔗 [https://itch.io/jam/finally-finish-something-2024](https://itch.io/jam/finally-finish-something-2024)
📅 January 1st - February 4th
@@ -30,7 +30,7 @@ Be honest, how high is your stack of unfinished games that you once were sure wo
### 3. Queer Vampire Jam
-🔗 [https://itch.io/jam/queer-vampire](https://itch.io/jam/queer-vampire)
+🔗 [https://itch.io/jam/queer-vampire](https://itch.io/jam/queer-vampire)
📅 January 10th - February 20th
@@ -38,7 +38,7 @@ While there are a plethora of “niche” game jams at any given time, it seems
### 4. Game Dev Knock Out (GDKO) - Round 1
-🔗 [https://itch.io/jam/gdko-2024](https://itch.io/jam/gdko-2024)
+🔗 [https://itch.io/jam/gdko-2024](https://itch.io/jam/gdko-2024)
📅 January 1st - January 15th
@@ -46,7 +46,7 @@ The Squid Games of the game dev world. The previous sentence is taken straight f
### 5. New Year, New Skills Game Jam
-🔗 [https://itch.io/jam/new-year-new-skills-game-jam](https://itch.io/jam/new-year-new-skills-game-jam)
+🔗 [https://itch.io/jam/new-year-new-skills-game-jam](https://itch.io/jam/new-year-new-skills-game-jam)
📅 January 7th - January 14th
@@ -54,7 +54,7 @@ An explicitly beginner-friendly jam organized by [Bitter Sails Games](https://tw
### 6. Godot Wild Jam #65
-🔗 [https://itch.io/jam/godot-wild-jam-65](https://itch.io/jam/godot-wild-jam-65)
+🔗 [https://itch.io/jam/godot-wild-jam-65](https://itch.io/jam/godot-wild-jam-65)
📅 January 12th - January 21st
@@ -70,7 +70,7 @@ A jam organized by game developer & Twitch streamer [Pirate Software](https://tw
### 8. GlobalGameJam
-🔗 [https://globalgamejam.org/](https://globalgamejam.org/)
+🔗 [https://globalgamejam.org/](https://globalgamejam.org/)
📅 January 22nd - January 28th
@@ -80,7 +80,7 @@ From the numbers that are accessible to us, we can estimate that about __16% of
### 9. GGJ Next
-🔗 [https://ggjnext.org/](https://ggjnext.org/)
+🔗 [https://ggjnext.org/](https://ggjnext.org/)
📅 January 22nd - January 28th
@@ -88,7 +88,7 @@ Concurrent to the Global Game Jam this event by the same organizers caters to th
### 10. Trijam #254
-🔗 [https://itch.io/jam/trijam-254](https://itch.io/jam/trijam-254)
+🔗 [https://itch.io/jam/trijam-254](https://itch.io/jam/trijam-254)
📅 January 26th - January 29th
@@ -97,5 +97,3 @@ Is it possible to make a game in just three hours? The hosts of this fast paced
----
Did you join any game jams this month? Then don’t miss out on the opportunity to self-promote your projects under our __#JamJanuary__ posts which you can find here: [linkin.bio/godot](https://linkin.bio/godot).
-
-
diff --git a/collections/_article/migrating-animations-from-godot-4-0-to-4-3.md b/collections/_article/migrating-animations-from-godot-4-0-to-4-3.md
new file mode 100644
index 0000000000..97f90728c7
--- /dev/null
+++ b/collections/_article/migrating-animations-from-godot-4-0-to-4-3.md
@@ -0,0 +1,340 @@
+---
+title: "Migrating Animations from Godot 4.0 to 4.3"
+excerpt: "In Godot 4.3, a large number of animation features have been reworked since 4.0, so it's time to migrate your animations."
+categories: ["progress-report"]
+author: Silc Renew
+image: /storage/blog/covers/migrating-animations-from-godot-4-0-to-4-3.webp
+date: 2024-06-04 00:00:00
+---
+
+
+
+# TL;DR
+
+Animation features were still quite immature in 4.0 and there were many undefined behaviors. 4.3 has redefined many behaviors along with some options, so we recommend that you review your settings.
+
+- For blending and `RESET` animation
+ - [Deterministic blending](#deterministic-blending)
+- For `Discrete` value (int, resource and etc.) animation
+ - [CallbackModeDiscrete](#callbackmodediscrete)
+- For `Capture` update mode
+ - [capture()](#capture)
+- For `AnimationNodeStateMachine`
+ - [NodeStateMachine - State Machine Type](#nodestatemachine---state-machine-type)
+
+# Description
+
+I'm glad to write this article because it means that animation in Godot 4 is now reaching a stable phase.
+
+We announced many improvements to Godot's animation systems when we released Godot 4.0. The work hasn't slowed down and there has been a gigantic amount of reworking done internally between Godot 4.0 and Godot 4.3, it has been like driving on a super bumpy road.
+
+
+
+After the launch of Godot 4.0, we have taken care to ensure that each change does not cause a major breakdown in compatibility. However, there are cases where we cannot avoid making changes to old projects. So we always try to provide some options in such cases, but there may be cases where manual configuration by the user is required.
+
+Despite extensive class references and documentation, we've lacked practical migration guidelines. Now, at this ideal time, I will explain how to upgrade your projects using real-world examples
+
+I also recommend that even those who do not need to migrate take a look at these, as you can learn about some interesting new features.
+
+# Timeline
+
+Here is a timeline of the availability of features by version for features that were temporarily affected by the rework.
+
+
+
+# Introduce New Features
+
+Here are the options and methods that have been changed or added between 3.x and 4.3.
+
+## AnimationMixer
+
+`AnimationMixer` is a new Node implemented in 4.2 that becomes the base class for `AnimationPlayer` and `AnimationTree`.
+
+
+
+The `AnimationMixer` has the role of managing the `AnimationLibrary` list and applying the blending results. In other words, the `AnimationMixer` does not have the role of processing time progression such as playback, but receives time information processed by child classes such as `AnimationPlayer` and `AnimationTree` and blends those key values.
+
+`AnimationTree` now can manage the `AnimationLibrary` list by itself without the need for `AnimationPlayer` by inheriting `AnimationMixer`. For compatibility, it is also possible to specify an `AnimationPlayer` and use its list as before.
+
+This unification of `AnimationPlayer` and `AnimationTree` will ensure the equivalence of most functions after 4.2. This means that prior to 4.2, `AnimationPlayer` and `AnimationTree` worked with different code although there was some duplication.
+
+The `AnimationMixer` fixed a large number of bugs that came from the inconsistencies between `AnimationPlayer` and `AnimationTree`, but it also raised some potential bugs to the surface. We have been hard at work resolving these new bugs.
+
+
+
+Also, several options needed to be added to keep old behaviors. After 4.2, AnimationTree and AnimationPlayer have different default values for the AnimationMixer property, which is based on compatibility with the old behavior.
+
+When implementing those base classes, one of the particular difficulties was the compatibility of the blending algorithms. Blendings could be nested many times, and it was necessary to consider what behavior was desirable for the user in each use case. Also, the blending weights calculation in 3.x was not consistent enough, so we needed to rewrite that algorithm to ensure that the result was calculated correctly.
+
+
+
+### Deterministic blending
+
+This is a new option implemented in Godot 4.2. In fact, AnimationTree always had been applied with this option in Godot 4.0 and 4.1.
+
+
+
+This is an option mainly to control cases where the total blending weight is `0`.
+
+**For example:**
+
+When comparing two animations, there are cases where only one has a track and the other does not.
+
+
+
+
+When `animation1` and `animation2` are blended so that `animation2` is 100%, the scale track will have the total blending weight is `0` in the result.
+
+**We can expect two possible behaviors in here:**
+
+1. Do nothing
+2. Apply default value
+
+In 3.x both AnimationTree and Animation player used option 1. In Godot 4.0 and 4.1, AnimationPlayer used option 1 but AnimationTree used option 2.
+
+AnimationTree starting using option 2 in 4.0 because it was necessary to process additive blending correctly.
+
+In additive blending, cases where the total weight of blending is `total_weight < 1` or `total_weight > 1` the value must be interpolated from the default value. This means that if the total blending weight is `0`, the animation will be set to the default value. This means that if one animation has no track in the blending, the default value will be applied, and the result will look like performing a reset.
+
+This reset behavior is also convenient with retargeting which was introduced in 4.0.
+
+Some models may have extra bones between the retargeted bones. In this case, when blending occurs with an animation that does not have extra bones, the appearance will be inconsistent if the extra bones are not reset.
+
+**For example:**
+
+Model A has an animation "look up" with 3 bone tracks.
+
+
+
+Model B has an animation "bow" with 4 bone tracks.
+
+
+
+Then, let's play these animations sequentially without resetting.
+
+
+
+It creates a condition where the appearance of the animations do not match between them. So, as you can see from the results, the 3D model pipeline required that resetting behavior.
+
+However doing this caused issues in some cases. Especially frequently reported were cases using `AnimationNodeStateMachine` with 2D projects.
+
+If there is no crossfade in the `AnimationNodeStateMachine` transition, the animation appears to suddenly switch without blending, but internally it is blending, which causes the resetting. This was confusing because it was appeared to be doing the same thing as AnimationPlayer, but it was behaving differently.
+
+Finally, we added a `Deterministic` option in 4.2 that allows the user to set whether the resetting is enabled or not. Also, now that `Deterministic` blending is available in AnimationPlayer, there are more possibilities for projects that use AnimationPlayer.
+
+**For example, this is useful when animating a GUI:**
+
+#### Non-deterministic behavior
+
+
+
+#### Deterministic behavior
+
+
+
+Finally, note that if the `Deterministic` option is disabled, the total weight of blending will be normalized, so additive blending will not work as expected.
+
+### CallbackModeDiscrete
+
+From what I have seen so far, not many people understand the behavior of the update mode `Discrete`.
+
+When keying `Discrete` values such as `int`, `bool` and other non-numerical type, the `UpdateMode` defaults to `Discrete`.
+
+
+
+On the other hand, `InterpolateType` has a `Nearest`.
+
+
+
+What is the difference between them?
+
+**Here is a diagram of how they work as the animation progresses:**
+
+
+
+As you can see, the frequency with which object values are updated is different.
+
+**Not only the frequency, but also the timing of the value updates is different within a single frame:**
+
+
+
+Since `Discrete` assumes that there is no blending, it sets the value of the object during the blending process, but `Continuous` sets the value to the object after the blending process has been completed. This means that when blending `Discrete` and `Continuous` tracks, the result of the `Continuous` track will always take precedence over the `Discrete` track.
+
+That was a problem because the `Deterministic` blend resetting behavior explained above is done as a `Continuous` mode.
+
+When implementing the `AnimationMixer` and `Deterministic` options in 4.2, we tried to solve that problem by implicitly converting `Discrete` mode to `Continuous` mode when blending occurs.
+
+However, this implicit conversion created another problem when the user understood the behavior of the `Discrete` track and the project relied on the infrequent application of `Discrete` values.
+
+In 4.3, now the user can choose whether or not to force conversions, so they can be handled them explicitly.
+
+**Here is how the options behave when `Discrete` and `Continuous` are blended:**
+
+There are two animations, one is `Continuous` and one is `Discrete`.
+
+
+
+#### Force Continuous
+
+Discrete track is treated as a `Continuous` track and they are blended together.
+
+
+
+#### Dominant
+
+Only on frames with `Discrete` track keys, the `Continuous` track results are not reflected as the `Discrete` track values are given priority.
+
+
+
+Note that instead of respecting the Discrete value, flicker may occur during blending.
+
+#### Recessive
+
+In frames with `Discrete` track keys, the `Discrete` track values are potentially reflected, but are immediately overwritten by the `Continuous` track results, so the final result appears to only `Continuous` track.
+
+
+
+Flickering does not occur and tends to look better. But note that if the `Continuous` track is blended even a little, the `Discrete` track result may be hidden.
+
+By the way, note that `AnimationPlayer` is set to `Recessive` by default but `AnimationTree` is set to `Force Continuous` by default. Since it works well with the `Deterministic` mode which is enabled by default, and on the basis of the many issues that have been posted from many users who reported that "discrete tracks cannot blend".
+
+### capture()
+
+The animation `UpdateMode` has an option `Capture` in addition to `Discrete` and `Continuous`.
+
+For those who are not familiar with the capture function, it is a feature that allows an object's current value at the moment of animation playback to be interpolated with the playback animation to allow smooth transition into the animation in cases where the object's value is changed outside of the animation.
+
+
+
+This method did not exist between 4.0 and 4.2. Instead, it was supposed to work by having `AnimationPlayer` read the `Capture` flag during playback, but that process was very tightly coupled with `AnimationPlayer`'s internal processing. However, when `AnimationMixer` was implemented in 4.2, the part that handled the capture was removed, so it was not working during 4.2 temporarily.
+
+Now, in 4.3, that tight coupling has been solved and revived in a more generalized and available in the `AnimationTree` as well.
+
+## AnimationPlayer
+
+In 4.2, the root motion which was only available in AnimationTree until 4.1, is now available by the implementation of AnimationMixer.
+
+
+
+### play_with_capture()
+
+A wrapper function that calls `play()` with `capture()` which was added in 4.3. If the animation has a capture track, capture interpolation is performed. The argument allows for more detailed settings.
+
+### Auto Capture
+
+In short, it is an option that makes play() call `play_with_capture()` instead. The argument of `play_with_capture()` executed by this option refers to these properties.
+
+
+
+If you want to control the behavior in more detail or specify individual arguments, you can disable `Auto Capture` and use `play_with_capture()` manually.
+
+## AnimationTree
+
+A lot of fundamental reworking has been done to get the time progression right. This provides a way to get semantic time between BlendTrees and should allow users to more strictly control their behavior.
+
+
+
+Also, the AnimationTree now can work stand-alone without AnimationPlayer to retrieve the animation list.
+
+
+
+### NodeStateMachine - State Machine Type
+
+This option was added by the StateMachine rework in 4.1 to control the behavior of nested StateMachines.
+
+**StateMachines are divided into three types depending on their use cases:**
+
+
+
+#### Root
+
+The most basic StateMachine.
+
+When this is nested, the parent AnimationNode considers the Root StateMachine to be finished when it is in the End state. If the parent AnimationNode commands the Root StateMachine to play from the beginning, the Start state is set.
+
+#### Nested
+
+This option is for use cases when we want to apply a time processing only to the current State in the StateMachine.
+
+If it is nested, the parent AnimationNode will consider the Nested StateMachine to be finished if it is in the End state, or if the State's transition destination does not exist and it is a dead end. If the parent AnimationNode commands the Nested StateMachine to play from the beginning, the animation in the current State is sequenced to position 0.
+
+This is mainly used in cases where states are not connected by a transition. That is, it can be used to reproduce the behavior of an Any state.
+
+
+
+#### Grouped
+
+This can be used to visually organize the States to avoid bloat in the StateMachine.
+
+Grouped StateMachines are not allowed to be played directly by the user using the playback object, but must be played from the parent StateMachine. This means that it must always have a Root or Nested StateMachine as an ancestor.
+
+Here is a diagram of the structure and behavior:
+
+
+
+**For example, if you want to play Attack2 in the above case, the script could be written as follows:**
+
+```gdscript
+var state_machine: AnimationNodeStateMachinePlayback = $AnimationTree.get("parameters/playback")
+state_machine.play("Attack/Attack2")
+```
+
+Also, `Grouped` type never stays in the `Start` state and `End` state. The `Start` state of a `Grouped` type is equal to the next state after the `Start` state of the state machine as seen by the parent state machine. The `End` state of a `Grouped` type is equal to the next state of the state machine in the parent state machine. In other words, those transitions are replaced by the parent state machine transitions.
+
+**In short, a more direct representation of the above diagram is equivalent to the following:**
+
+
+
+Note that currently StateMachine does not have user-controllable indexes for connections and cannot have multiple Start/End states, so Grouped StateMachine is limited to having only one input/output. This limitation may be removed in the future by StateMachine enhancements.
+
+### NodeOneShot / NodeTransiton / StateMachineTransition - Break Loop at End
+
+
+
+In the 4.1 StateMachine rework, we made the AnimationNode have an infinite-length remain time in a loop and for StateMachines with unpredictable endings as a hack. We did this becauses the old AnimationNode only returned the remaining time after the processing but there was no information there about whether it was looping or not. This change was necessary to prevent unintended animation interruptions for consistency, but it removed the existing behavior of breaking the loop at `AtEnd` and doing a Transition.
+
+In 4.3, the AnimationNode time progression has been reworked significantly to propagate semantic time information. Now a BreakLoopAtEnd option has been added for use cases where the loop is broken by `AtEnd`.
+
+This option makes it easier to implement things like `AtEnd` transitions after several loops.
+
+### NodeAnimation - Custom Timeline
+
+As a byproduct of the time progression reworking, it is now possible to adjust the period and length of the animation in the AnimationNode.
+
+
+
+This should help to solve problems with synchronization of foot step animation when blending walking and sideways walking animations, or walking and running animations.
+
+# The future of the animation feature
+
+Compared to the Godot 3 code, you can see that almost all of the code has been rewritten in the animation area.
+
+I have focused mostly on reworking and stabilizing features from Godot 3 that were unstable or not well-defined. I expect that such fundamental rework will be settled in 4.3, allowing us to focus on adding more features from now on.
+
+I already have several proposals that I have written myself, but I am also interested in some proposals that have come from the community, so I hope to pick up on those as well.
+
+## Support
+
+Godot is a non-profit, open source game engine developed by hundreds of contributors on their free time, as well as a handful of part or full-time developers hired thanks to [generous donations from the Godot community](https://fund.godotengine.org/). A big thank you to everyone who has contributed [their time](https://github.com/godotengine/godot/blob/master/AUTHORS.md) or [their financial support](https://github.com/godotengine/godot/blob/master/DONORS.md) to the project!
+
+If you'd like to support the project financially and help us secure our future hires, you can do so using the [Godot Development Fund](https://fund.godotengine.org/) platform managed by [Godot Foundation](https://godot.foundation/). There are also several [alternative ways to donate](/donate) which you may find more suitable.
diff --git a/collections/_article/platform-state-in-csharp-for-godot-4-2.md b/collections/_article/platform-state-in-csharp-for-godot-4-2.md
index 3d428ea6fe..a7b097fc95 100644
--- a/collections/_article/platform-state-in-csharp-for-godot-4-2.md
+++ b/collections/_article/platform-state-in-csharp-for-godot-4-2.md
@@ -85,9 +85,9 @@ As a summary, the current platform support as of 4.2 is described in the table b
| Platform | Runtimes supported | Minimum required .NET version |
| -: | - | - |
-| **Windows** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR, Mono), 7.0 (NativeAOT) |
-| **macOS** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR, Mono), 7.0 (NativeAOT) |
-| **Linux** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR, Mono), 7.0 (NativeAOT) |
+| **Windows** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR), 7.0 (Mono, NativeAOT) |
+| **macOS** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR), 7.0 (Mono, NativeAOT) |
+| **Linux** | CoreCLR, Mono, NativeAOT | 6.0 (CoreCLR), 7.0 (Mono, NativeAOT) |
| **Android** | Mono | 7.0 |
| **iOS** | NativeAOT | 8.0 |
| **Web** | - | - |
diff --git a/collections/_article/progress-report-web-export-in-4-3.md b/collections/_article/progress-report-web-export-in-4-3.md
new file mode 100644
index 0000000000..faddf6ebea
--- /dev/null
+++ b/collections/_article/progress-report-web-export-in-4-3.md
@@ -0,0 +1,198 @@
+---
+title: "Web Export in 4.3"
+excerpt: "With single-threaded builds and sample playback, it's now easier than ever to export your game to the Web with Godot 4.3. And more!"
+categories: ["progress-report"]
+author: Adam Scott
+image: /storage/blog/covers/progress-report-web-export-in-4-3.webp
+image_caption_title: "Catburglar"
+image_caption_description: "An open source game by @JohnGabrielUK and his team"
+date: 2024-05-15 13:15:00
+---
+
+Have you ever begun some type of work, and only after realized how little you actually knew? That happened to me during [the last
GDC](https://godotengine.org/article/gdc-2024-retrospective/).
+
+A few months ago, I took over [Fabio Alessandrelli's (@faless)](https://github.com/Faless/) responsibilities as [Web Platform Lead](https://godotengine.org/teams/#platforms) for Godot to reduce his task load and accelerate the pace at which our Web platform exports continue to improve.
+
+I'm well used to the Web and its quirks. I began creating websites in
XHTML and (vanilla) JavaScript, back in the days. Flash games were my jam! Enough so that I even worked for a video game studio as an ActionScript 3 developer in 2010. And I didn't really stop caring about the Web platform ever since.
+
+Since then, Flash may have died, but online games didn't.
+
+# The new situation
+But what I realized at the
GDC is that we're entering into a sort of Golden Age of Web games. Not only websites like [Poki](https://poki.com/) or [Crazy Games](https://www.crazygames.com/) are super popular, but big players are starting to integrate Web games into their services, such as
+[Discord Activities](https://support.discord.com/hc/en-us/articles/4422142836759-Activities-on-Discord) or [YouTube Playables](https://www.youtube.com/playables). All these entities want developers to create games for their platform, and they are all asking how Godot can bring a first-class development experience to it.
+
+# Godot 4.3
+Making games for the Web using Godot 4.x still isn't as seamless as we would like it to be. Unfortunately serious revisions are needed to improve the experience to the extent that we want.
+
+Godot 4.3 promises to be one of the best recent releases for Web exports. One of the biggest issues relating to this has been properly fixed: single-threaded exports.
+
+## Single-threaded Web export
+
+### Betting on the wrong horse
+[`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer)s were supposed to revolutionize the Web. And they did. That API permits to share memory between [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) (which are the Web native "threads").
+
+Unfortunately, we live in the same timeline that includes the [Spectre and Meltdown exploits](https://meltdownattack.com/).
+
+The result of this is that [browsers greatly reduced where and how you can use that API](https://developer.chrome.com/blog/enabling-shared-array-buffer?hl=en). Namely, browsers nowadays require websites to be [cross-origin isolated](https://web.dev/coop-coep/). When isolated, it does unlock the potential of `SharedArrayBuffer`s, but at what cost?
+
+At the cost of having the capacity to make remote calls to other websites. _Adieu_ game monetization. _Adieu_ interacting with an external API.
+
+The issue is that during the development of Godot 4, we bet on the wrong horse: we went all-in with using threads with `SharedArrayBuffer`s. We thought it was mainly a question of [browser support](https://caniuse.com/sharedarraybuffer) (which took a step back due to the aforementioned security issues), so when all browsers finally shipped stable releases with `SharedArrayBuffer`, we streamlined everything around multi-threading.
+
+But we underestimated the difficulty of configuring cross-origin isolated websites.
+
+We know it has been a hurdle for a lot of users trying to publish their jam games on [itch.io](https://itch.io), which has an experimental `SharedArrayBuffer` option, but relying upon another feature ([`coep:credentialless`](https://caniuse.com/mdn-http_headers_cross-origin-embedder-policy_credentialless)) not supported by Safari or Firefox for Android).
+
+Likewise, most Web games are being published on third-party publishing platforms where the game authors may not even be able to set the required headers for `SharedArrayBuffer` support.
+
+### Backporting the single-threaded feature from Godot 3.x
+At the end of the development of Godot 4.2, [the Foundation](https://godot.foundation/) tasked me to find a way to backport the ability to build Godot without using threads in order to export Godot games without the pesky
COOP/
COEP headers.
+
+This was not easy because 4.0 was made with threads in mind. It maybe explains why we were so hesitant to go ahead with this change. Fortunately, with the help of our thread guru [Pedro J. Estébanez (@RandomShaper)](https://github.com/RandomShaper), I was able to tame the beast and put back single-threaded builds.
+
+[My
PR](https://github.com/godotengine/godot/pull/85939) was finally merged at the beginning of the Godot 4.3 development period.
+
+
+
+It even had some unexpected benefits. Apple devices (macOS and iOS) were long known to have issues when playing Godot Web exports. Well, when you do export your game single-threaded, these issues fortunately disappear.
+
+However, it came with a downside too: it introduced a new, virtually unsolvable bug:
+
+The single-threaded build introduced garbles in the audio of games, making them unplayable on low-end machines such as laptops or phones, or high-end machines with high frame rates.
+
+When I mean unplayable, I mean it. [Try it yourself.](https://adamscott.github.io/2d-platformer-demo-main-thread/){:target="_blank"} (Consider yourself lucky if it doesn't glitch out.)
+
+_Please note: we know that there's some issues running Platformer 2D on Safari, namely the browser reloading the page complaining that "this webpage is using significant memory". We're currently investigating to fix this
ASAP._
+
+Yes. Web single-threaded audio stream playback with Godot 4.2 is that bad. It is marginally better on Godot 3.x, but the problem exists there as well.
+
+## Sample playback to the rescue!
+[Here comes my
PR](https://github.com/godotengine/godot/pull/91382) (not yet merged at the time of writing) for the rescue. [Here's the same demo without sound issues.](https://adamscott.github.io/2d-platformer-demo-main-thread-samples/){:target="_blank"}
+
+### What are samples?
+Using samples for games is not a novel idea. In fact, for a long time, it was the _de facto_ way to play sound and music on game consoles. As they didn't have the processing power to do the mixing on the CPU, you could send audio clips (hence the term "sample") to a special chip and tell it how and when to play them.
+
+Since the audio chip was operating on its own, the sound would never lag nor glitch out if the game is lagging.
+
+### (Re)introducing samples to Godot
+When open sourced, the Godot engine offered two ways to emit audio: streams for music and samples for sounds.
+
+
+
+But when Godot 3 released, it was decided that samples support was not needed anymore. Game consoles nowadays ask developers to mix themselves the samples using the CPU. And for the Web, we could mix the audio using a dedicated thread, like other platforms since `SharedArrayBuffer`s exist.
+
+This is why there's audio garbles in single-threaded builds (without my "fix"). Audio rendering is tied with the frame rate. And if it drops, there's not enough audio frames to fill out the buffer, hence the glitches.
+
+What [my
PR](https://github.com/godotengine/godot/pull/85939) does is to reinstate sample playback. At least at the time of writing, for the Web platform only.
+
+### Near seamless integration
+From the get-go, it was something that we ruled out: we couldn't simply port how it was done in 2.1, we needed a more intuitive way.
+
+Then, I hacked samples into stream. I more or less hijacked the streams API to insert samples support. Simple as that!
+
+
+
+`AudioStreamPlayer`, `AudioStreamPlayer2D`, and `AudioStreamPlayer3D` have a new "Playback Type" property which determines how these nodes will behave behind the scenes. You can choose between "Stream", "Sample", and "Default".
+
+
+
+Fortunately, "Default" uses the new default project settings value `audio/general/default_playback_type`, so on the Web, the project will use "Sample" and the rest of the platforms will keep using "Stream".
+
+When an `AudioStreamPlayer` wants to play a sample, it will check if it's registered first. If not, it will register it before playing it. Please note that not all samples can be registered, as only static ones can be (wav, ogg vorbis, mp3).
+
+
+
+On low-end devices, to make sure that they aren't encountering lag spikes when registering samples just before playing them, I recommend to register them manually while loading the level. You just have to call the new API `AudioServer.register_stream_as_sample()`.
+
+Other than these details, your game should pretty much work as is on the Web, without the pesky crackling noise. But under the hood, the audio is handled in a completely different way. Kinda weird, isn't it?
+
+#### Under the hood
+If the API stays pretty much the same, we cannot say the same thing about how `AudioStreamPlayer`s, `AudioServer`, and `AudioDriver` work internally.
+
+Usually, everything is set in place to mix streams of audio by small chunks, determined by the audio latency in the project settings. If the audio latency setting is set at 15ms, Godot will make sure to keep filled a memory buffer worth of 15ms of audio.
+
+To do that, each cycle, the `AudioServer` will go through each audio stream. If it's active, it will mix the frames it needs to fill the buffer.
+
+_Inside Godot, [servers are what's underneath most of the nodes](https://docs.godotengine.org/en/4.2/tutorials/performance/using_servers.html), logic-wise. The nodes explain what and how to do to the servers, which image to show, which sound to stop, which 3D model to load and where._
+
+Now, if the audio stream is considered a "sample", the `AudioServer` will ignore it in the mixing phase. But each time, a sample is played or paused, it must call the `AudioDriver` (here, the `AudioDriverWeb`) to tell it what happened.
+
+
+##### Web audio node chains
+If a sample is added, a Web Audio node chain representing a sample will be added. If an audio bus is removed, a Web Audio node chain representing an audio bus will be removed.
+
+Doing this permits some sort of one-to-one connection between the `AudioServer` state and the Web audio API, which makes it possible to recreate somewhat accurately the mixing happening on the Godot side with streams.
+
+
+
+Here's an image showing the Web audio nodes of the intro scene of [Catburglar](https://johngabrieluk.itch.io/catburglar), the open-source game featured on the cover. It is where all the samples are getting mixed.
+
+From the right to the left of that image, you have the destination node (the audio output), then the master bus (represented by a chain of nodes). Plugged to the master bus are the rest of the audio buses determined by the project. All the buses have multiple `GainNode`s to handle actual gain, solo and mute.
+
+Then, you see a sample chain, with its weird splitter and merger nodes. This is where the magic happens.
+
+Each cycle, for mixing the streams, Godot calculates the volume of each audio channel. As Godot supports up to 7.1 surround (5.1 surround on the Web), it must know how loud to actually play the stream in the left and right speaker, the center one, the
LFE, and so on. All according to the volume,
+position, and orientation of the node.
+
+So, to handle all of that on the Web Audio side, we send those values to each channel, and it just works.
+
+#### It works out-of-the-box
+You want proof that it works out-of-the-box? Here's some projects that I just opened with my PR build and I exported them right away (using the single-threaded export option and using the (new) default project values).
+
+| Game title | Single-threaded samples build | Project page |
+| ---------- | :---------------------------: | :----------: |
+| Truck Town | [Play](https://adamscott.github.io/truck-town-main-thread-samples/){:target="_blank"} | [Link](https://github.com/godotengine/godot-demo-projects/tree/master/3d/truck_town){:target="_blank"} |
+| Platformer 2D | [Play](https://adamscott.github.io/2d-platformer-demo-main-thread-samples/){:target="_blank"} | [Link](https://github.com/godotengine/godot-demo-projects/tree/master/2d/platformer){:target="_blank"} |
+| Dodge the Creeps 2D | [Play](https://adamscott.github.io/2d-dodge-the-creeps-demo-main-thread-samples){:target="_blank"} | [Link](https://github.com/godotengine/godot-demo-projects/tree/master/2d/dodge_the_creeps){:target="_blank"} |
+| Platformer 3D | [Play](https://adamscott.github.io/3d-platformer-demo-main-thread-samples/){:target="_blank"} | [Link](https://github.com/godotengine/godot-demo-projects/tree/master/3d/platformer){:target="_blank"} |
+| Catburglar | [Play](https://adamscott.github.io/catburglar-main-thread-samples/){:target="_blank"} | [Link](https://johngabrieluk.itch.io/catburglar){:target="_blank"} |
+
+Many thanks to the awesome [Catburglar](https://johngabrieluk.itch.io/catburglar) team (John Gabriel, Jerico Landry, Kyveri, Sacha Feldman, and Carrie Drovdlic). Without this [open-source project](https://bitbucket.org/JohnGabrielUK/catburglar/), made for the [63rd](https://itch.io/jam/godot-wild-jam-63) [Godot Wild Jam](https://godotwildjam.com/), I wouldn't have solved as many bugs as I did. Please try it out! The audio work, in particular, sounds incredible.
+
+### Here be dragons
+Even if the odds are that sample playback will be a part of Godot 4.3 release, it was developed very quickly, and even if it works pretty well, if you ask me, it still is pretty much a prototype. But we can't just release Godot 4.3 without proper audio support for single-threaded releases.
+
+So it has been decided that it should be treated as _experimental_. More work will be done before the release of Godot 4.4 in order to stabilize the API and how it works under the hood.
+
+### Call to action
+But even before thinking about Godot 4.4, I must call for your help! We need people to test out [the sample playback
PR](https://github.com/godotengine/godot/pull/85939) until the release.
+
+If you encounter any issue while testing my PR or while testing out the single-threaded samples builds, please report them [here](https://github.com/godotengine/godot/pull/85939).
+
+Finally, if you still intend to continue using threads on the Web platform, you can! And the next feature should aid you setup your game online.
+
+## Easy
COOP-
COEP PWA for threaded builds
+With this new feature, if you still need to export your game with thread support, you'll are able to activate the necessary
COOP/
COEP headers without having to modify the server's header responses. You'll need to export your game as a Progressive Web App though.
+
+
+
+This is because this export option sets up the Service Worker, included with the
PWA build, to intercept the requests from the server and inject those missing
COOP-
COEP headers.
+
+## Boot splash screen
+Just before the beta feature freeze deadline, [@patwork](https://github.com/patwork), a new [#web](https://chat.godotengine.org/channel/web) contributor,
+included [some neat features](https://github.com/godotengine/godot/pull/91128):
+
+He cleaned up the game page code and he updated the progress bar to use the semantic (and very useful) HTML `
Contact us
+Contact us