PackedInt64Array in Godot – Complete Guide

Welcome to our tutorial on the PackedInt64Array class in Godot 4, where you’ll discover how to utilize this powerful data structure to its full potential. Throughout this guide, we’ll journey together through understanding, implementing, and mastering the PackedInt64Array class to enhance your game development toolkit. Whether you’re a budding programmer or an experienced coder, this tutorial promises an engaging journey into one of the exciting areas of Godot Engine’s scripting capabilities.

What Is PackedInt64Array?

The PackedInt64Array is among the many specialized array types offered by Godot. Specific to 64-bit integers, it boasts an efficient memory footprint, making it ideal for handling large datasets.

What Is It For?

At first glance, you might ponder the need for something like PackedInt64Array. Its purpose lies in its optimization for memory usage and performance when dealing with vast quantities of integer data, such as high scores in a leaderboard or unique IDs in a sprawling game world.

Why Should I Learn It?

Understanding and applying PackedInt64Array effectively can lead to more than just good memory management in your games. It gives you a deeper insight into how Godot handles data, thus enabling you to craft richer, more complex gameplay experiences. Learning to use PackedInt64Array is a valuable step in becoming proficient with Godot Engine and, by extension, becoming a better game developer.

CTA Small Image

Creating and Initializing a PackedInt64Array

Let’s kick things off by learning how to create a PackedInt64Array and initialize it with some values. The creation process is similar to any other array in Godot, and you can either initialize it with a predefined set of values or start with an empty array.

var array_with_values = PackedInt64Array([1, 2, 3, 4, 5])
var empty_array = PackedInt64Array()

You can also append values to your PackedInt64Array after creation, which makes it dynamic and adaptable throughout runtime.

empty_array.append_array(PackedInt64Array([7, 8, 9]))

As you manipulate your PackedInt64Array, remember that each element must be a 64-bit integer. Trying to insert a value of a different type will cause an error.

Accessing and Modifying Elements

Accessing and modifying elements in PackedInt64Array is straightforward. You can access elements by their index and modify them just as easily.

# Access the first element
var first_element = array_with_values[0]

# Modify the second element
array_with_values[1] = 100

Bear in mind that Godot uses zero-based indexing, so the first element is at index 0.

When modifying elements, if the new value doesn’t fit within the 64-bit integer range, Godot will raise an error, ensuring the integrity of your PackedInt64Array’s data.

Iterating Over a PackedInt64Array

Iteration through a PackedInt64Array is a common operation and can be done using familiar iteration syntax known from other programming languages.

for number in array_with_values:
    print("Number:", number)

Alternatively, you can iterate using indices if you need to manipulate the index or elements dynamically during the iteration.

for i in range(array_with_values.size()):
    # Increment each number by 10
    array_with_values[i] += 10

Iteration is a powerful feature when manipulating data, aggregating statistics, or simply displaying values in the UI.

Using PackedInt64Array with Godot’s Functions and Signals

Godot’s PackedInt64Array seamlessly integrates with the engine’s functions and signals. You can pass it around, store it in signals, and even save it to files or load it from them.

# Signal with a PackedInt64Array parameter
signal numbers_updated(new_numbers:PackedInt64Array)

# Emit the signal with an array
emit_signal("numbers_updated", array_with_values)

# Saving to file
var file ="user://scores.dat", File.WRITE)

# Loading from file"user://scores.dat", File.READ)
var loaded_array = file.get_var()

This compatibility allows you to leverage the power of Godot’s ecosystem, ensuring that your usage of PackedInt64Array is not just limited to array-specific operations but extended to the entire Godot environment.Using PackedInt64Array in mathematical operations can yield efficient results, especially when dealing with large sets of numeric data.

# Adding a value to all elements
for i in range(array_with_values.size()):
    array_with_values[i] += 10

If you need to find if a particular value exists within your PackedInt64Array, you can use the ‘find’ method:

var index_of_value = array_with_values.find(100)
if index_of_value != -1:
    print("Value found at index: ", index_of_value)
    print("Value not found")

Packed arrays in Godot allow easy conversion between different types of Packed arrays.

var float_array = PackedFloat64Array([1.0, 2.0, 3.0])
var converted_from_float = PackedInt64Array(float_array)

Also, consider scenarios where you need to perform bulk operations, like clearing an array or resizing it:

# Clearing all elements from the array

# Resizing the array (new size is 10, filled with zeros)

When resizing, new elements will be initialized with a default value of zero. Slotted directly into Godot’s expression of GDScript, this aligns with the simplicity of managing dynamic content during game development.

Complex operations, such as sorting the array, can be accomplished with ease:

# Sort the array in ascending order

Or suppose you need to create a copy of a PackedInt64Array. This may be useful when you want to work with the data without altering the original set:

# Create a shallow copy of the array
var array_copy = array_with_values.duplicate()

Remember, a shallow copy means both arrays will reference the same data until you modify any of the elements; at that point, Godot ensures the two arrays no longer share the same data.

Lastly, let’s take a look at how we can interface with a more complex data structure like a dictionary by converting our PackedInt64Array:

# Convert PackedInt64Array to Dictionary
var number_dict = {}
for i in range(array_with_values.size()):
    number_dict[str(i)] = array_with_values[i]

This allows us to use the keys as identifiers, which can be particularly useful when you need a numerical ID associated with each value in the array.

Remember, our aim here at Zenva is to equip you with the knowledge and skills to craft phenomenal games using Godot. With every new feature and technique, you’re sharpening your ability to create, innovate, and bring your imaginative worlds to life. Stick with us to unlock new realms of coding prowess and game development expertise!As we delve further into using the PackedInt64Array, let’s explore how you can combine it with Godot’s powerful engine features to extend the functionality of your games.

Consider a scenario where you need to aggregate data, such as summing all the elements in a PackedInt64Array:

var sum = 0
for number in array_with_values:
    sum += number
print("The sum of all elements is: ", sum)

This simple loop allows for calculations across the array, which could be leveraged to calculate scores, resources, or any other metrics.

What if we want to compare two PackedInt64Arrays? We can design a function that compares the contents and verifies if they are identical:

func arrays_are_equal(array1: PackedInt64Array, array2: PackedInt64Array) -> bool:
    if array1.size() != array2.size():
        return false
    for i in range(array1.size()):
        if array1[i] != array2[i]:
            return false
    return true

# Example usage
var array1 = PackedInt64Array([1, 2, 3])
var array2 = PackedInt64Array([1, 2, 3])
print("Are arrays equal? ", arrays_are_equal(array1, array2))

In another instance, you might want to remove a specific element from the PackedInt64Array. You can do this by finding its index and then removing that index:

# Removing the element with a value of 100
var index_to_remove = array_with_values.find(100)
if index_to_remove != -1:

Besides the operations already discussed, you can do more complex manipulations, such as filtering elements in an array. Here’s a simple way to filter out all numbers below a certain threshold:

var threshold = 10
var filtered_array = PackedInt64Array()
for number in array_with_values:
    if number >= threshold:

# Displaying filtered results
print("Filtered Array: ", filtered_array)

What about integrating PackedInt64Array in Godot’s physics engine? For instance, tracking object IDs that are within a certain area in your game. When an object enters the area, its ID could be added to a PackedInt64Array:

# Assuming 'body' is the physics body entering the area
func on_area_body_entered(body):
    var body_id = body.get_instance_id()
    if !ids_in_area.has(body_id):

And likewise, when an object exits the area:

func on_area_body_exited(body):
    var body_id = body.get_instance_id()
    var index = ids_in_area.find(body_id)
    if index != -1:

By leveraging the PackedInt64Array in these various ways, you can maintain optimized and performant operations in your Godot projects. These examples showcase the versatility of PackedInt64Array, applicable from gameplay mechanics to data management. Remember, innovation is at the heart of what we do at Zenva. By incorporating these structures into your toolset, you’re adding a layer of sophistication to your game’s architecture and delivering an experience that stands out to your players. Keep experimenting and exploring the rich features offered by Godot, and soon enough, you’ll be capable of turning any creative concept into a tangible, interactive reality.

Where to Go Next with Godot Game Development

Well done on taking your first steps towards mastering the PackedInt64Array in Godot! But don’t let your journey end here. Expanding your game development skills is a continuous process filled with learning new techniques and sharpening your craft. To help you continue on this path, we at Zenva offer our comprehensive Godot Game Development Mini-Degree. This curriculum is designed to cover various aspects of game development, from the basics of using 2D and 3D assets to more complex topics like gameplay control flow and mechanics for different game genres.

Whether you’re a complete beginner or looking to build upon your existing skills, our courses are tailored to support your learning journey every step of the way. You’ll not only gain practical experience by building real Godot projects but also acquire in-demand skills that are highly valued within the game development industry. Plus, with the convenience of learning at your own pace, you can ensure that your education fits comfortably with your schedule.

For a broader view of what we offer, check out our full collection of Godot courses, each designed to boost your confidence and capabilities as a game developer. With Zenva, you can indeed go from a beginner to a professional, and we’re excited to be a part of your game development adventure. Continue building, continue learning, and most importantly, keep enjoying the process of bringing your gaming visions to life!


Congratulations on diving into the depths of the PackedInt64Array class with us, and broadening your toolkit for game development in Godot. With every new feature you master, you inch closer to turning your dream projects into interactive experiences for gamers around the world. Remember, this is just the beginning of the adventure, and there’s a whole universe within Godot waiting to bring your creativity to life.

We at Zenva are dedicated to your growth as a developer, and we’re thrilled to accompany you as you continue to develop your skills. Explore our Godot Game Development Mini-Degree to take the next step in your game development journey. Stay curious, keep learning, and let’s create amazing games together!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.