[DONE] Verse VM test—Friday, October 23rd, 8am-12pm ET

On Friday, October 23rd, we’re testing a new virtual machine (VM) for the Verse programming language on all Public and Private UEFN sessions. The test will run from 8am–12pm ET.

2026-10-23T12:00:00Z→2026-10-23T16:00:00Z

What should I expect?
During the test, users loading into a UEFN session (live) private and public sessions will be on the New VM.

What’s New compared to the last test?
In 42.40, Creators are able to toggle between the New and Old VM in a UEFN development and Live Edit session by:

  1. Selecting the three dot menu next to the Launch Session button

  1. Enable the Use Verse VM option

Hit something you think is related to the VM test?
Submit a report in this thread and include the following information:

  • Did this happen before the test window? If so, when?

  • Which island code are you seeing it on?

  • Steps to reproduce

  • How often does it happen: 10/10 times, or 1/10?

We’ll collect these and prioritize fixes internally before the next test.

The testing window is being extended to 3:00pm EST.

2 Likes

I was having issue when calculating private version for my map 6883-6554-3354 it was making me leave the the game to lobby then showed me connection error

The testing window has concluded, servers will be rolling over to the old VM after you join a new session.

Thanks for the info! We have this tracked for investigation!

We had a major game breaking bug that we received the first report for at 5:37AM PST (8:37 EST) which corrupted dozens our user persistent data that we couldn’t explain. We did a hotfix to our game last night and I thought it was related to that, but nothing we could see in code could explain it.

FWIW this is our map: https://fortnite.gg/island/9621-3035-2804

We had to unpublish our game, make a hotfix and have since published the change and things are mostly back to normal. That said, there are several other bugs that are now present that were not like that before (e.g. NPCs walking backwards).

The critical bug seems to have been due to a difference in how the Verse language was compiled and interpreted, and we had to make a change to code to accommodate. Is it possible the new VMs treat Verse code differently? We couldn’t explain why the bug occurred, so seeing this makes me think it might be related.

Hey. While testing the new Verse VM in edit sessions, we’ve encountered an issue with cancellation and defer.

The old Verse VM has a bug involving the following pattern:

Foo()<suspends> : void =
    defer. Print("Defer")
    race:
        # Expressions

If Foo is cancelled while the race is running, "Defer" is not printed. We’ve been using the following workaround:

Foo()<suspends> : void =
    branch:
        defer. Print("Defer")
        Sleep(Inf)
    race:
        # Expressions

With this workaround, "Defer" is printed whether Foo completes normally or is cancelled.

However, the workaround no longer works in the new Verse VM. This caused some issues in our island 4388-4237-1339. Although we have no evidence that public sessions have been affected, the issue is consistently reproducible in edit sessions.

1 Like

Following up on my post above, the issue we saw in a nutshell…

?int := false doesn’t resolve to the same key in a map as ?int := option{0 > 10}

Whereas before it did.

1 Like

Hey, thanks for reporting this. This is actually an expected behavior change. The new Verse VM fixes a bug in tasks where a function return would cancel the task. This is why you saw that branch get cancelled when Foo returns. This was never the intended semantics. In the new VM, returning from a function doesn’t cancel the tasks that the function created. Instead, the task boundary is totally agnostic of function boundaries. The new VM also fixes the bug you notice in defer in the old VM.

Would you be able to update your code to account for this behavior change? You could even write some helpers to conditionally detect which VM is running and adapt the code at runtime to do the right thing for what you expect.

Thanks

Thanks for the reply. So, is the intended behavior for branch to continue to run even after its enclosing function returns? In my tests, its lifetime appears to be tied to the top-level caller (e.g., OnBegin or OnSimulate), as long as the call chain is direct, with no calls inside race expressions. For reference, since we expected branch to finish when its enclosing function exited, we wrote the following workaround, which worked in both VMs:

Foo()<suspends> : void =
    branch:
        defer. Print("Sleeping branch workaround for the old VM")
        Sleep(Inf)
    race:
        # Expressions.

# Call site (changed for the new VM).
# Foo() # <- defer expressions within Foo's branch expressions are not cancelled when calling Foo directly.
# When inside a race expression, defer expressions within Foo's branch expressions get called when Foo returns or gets cancelled.
race:
    Foo()
    Sleep(Inf)

In this scenario, is it intended behavior for the branch expressions to get cancelled?

Yes, exactly. The intention is for branch to continue running until its parent task ends, so either a top-level caller like OnBegin or some other task boundary like race/sync/rush/branch/spawn. Your new workaround should do what you want.

1 Like

Can you expand on what your map’s keys are. Is it an optional int? Can you provide a fuller code example? Thanks!

This test passes in both VMs:

# Control: the reported expression fails, and both options are empty and equal.
assert:
    LiteralEmpty:?int = false
    FailedEmpty:?int = option{0 > 10}
    not (0 > 10)
    not LiteralEmpty?
    not FailedEmpty?
    LiteralEmpty = FailedEmpty

# Repro: insert the literal empty option, then look up the failed option.
assert:
    LiteralEmpty:?int = false
    FailedEmpty:?int = option{0 > 10}
    Values:[?int]int = map{LiteralEmpty => 42}
    Values[LiteralEmpty] = 42
    Values[FailedEmpty] = 42

# Repro in the opposite direction.
assert:
    LiteralEmpty:?int = false
    FailedEmpty:?int = option{0 > 10}
    Values:[?int]int = map{FailedEmpty => 42}
    Values[FailedEmpty] = 42
    Values[LiteralEmpty] = 42

# Set the failed option expression directly, replacing a literal false key.
# Bare false is accepted in the typed map literal but not as a set subscript.
assert:
    LiteralEmpty:?int = false
    var Values:[?int]int = map{false => 42}
    Values.Length = 1
    Values[LiteralEmpty] = 42
    Values[option{0 > 10}] = 42
    set Values[option{0 > 10}] = 99
    Values.Length = 1
    Values[LiteralEmpty] = 99
    Values[option{0 > 10}] = 99
    set Values[option{0}] = 7
    Values.Length = 2
    Values[LiteralEmpty] = 99
    Values[option{0}] = 7

# Insert into an empty mutable map using literal option expressions.
# The second expression is another empty ?int, produced by querying false.
assert:
    LiteralEmpty:?int = false
    var Values:[?int]int = map{}
    set Values[option{0 > 10}] = 42
    Values.Length = 1
    Values[option{0 > 10}] = 42
    Values[LiteralEmpty] = 42
    set Values[option{false?; 0}] = 99
    Values.Length = 1
    Values[option{0 > 10}] = 99
    Values[LiteralEmpty] = 99
    set Values[option{0}] = 7
    Values.Length = 2
    Values[option{0 > 10}] = 99
    Values[option{0}] = 7

# Updating through the other spelling replaces the existing entry.
# A present zero remains a distinct key.
assert:
    LiteralEmpty:?int = false
    FailedEmpty:?int = option{0 > 10}
    var Values:[?int]int = map{LiteralEmpty => 42, option{0} => 7}
    set Values[FailedEmpty] = 99
    Values.Length = 2
    Values[LiteralEmpty] = 99
    Values[FailedEmpty] = 99
    Values[option{0}] = 7

# Exercise option failure through a function parameter rather than just literals.
MakeOption(Value:int)<transacts>:?int = option{Value > 10}

assert:
    LiteralEmpty:?int = false
    FailedEmpty := MakeOption(0)
    not FailedEmpty?
    LiteralEmpty = FailedEmpty
    FromLiteral:[?int]int = map{LiteralEmpty => 42}
    FromFailure:[?int]int = map{FailedEmpty => 99}
    FromLiteral[FailedEmpty] = 42
    FromFailure[LiteralEmpty] = 99
    MakeOption(11)? = 11

# Widening the keys to comparable must preserve the same lookup behavior.
assert:
    LiteralEmpty:?int = false
    FailedEmpty := MakeOption(0)
    FromLiteral:[comparable]int = map{LiteralEmpty => 42}
    FromFailure:[comparable]int = map{FailedEmpty => 99}
    FromLiteral[FailedEmpty] = 42
    FromFailure[LiteralEmpty] = 99

# Map construction must also merge the two empty keys, retaining the last value.
assert:
    LiteralEmpty:?int = false
    FailedEmpty:?int = option{0 > 10}
    Values:[?int]int = map{LiteralEmpty => 42, FailedEmpty => 99, option{0} => 7}
    Values.Length = 2
    Values[LiteralEmpty] = 99
    Values[FailedEmpty] = 99
    Values[option{0}] = 7

I’ve found a repro. It has to do with hashing structs with mixed default values vs derived values. We had a bug where our hash function would report different hash values for equivalent structs. Fix incoming for 43.10.

Apologies, I don’t get notifications on responses unless I’m on the forum directly, which I tend to only use when I have a bug to report. Glad to see you reproduced it.

not related to the test itself but when using verse VM i’m stuck in loading (white lobby) until timeout. This only happens on new verse VM