Godot Engine – Multi-platform 2D and 3D game engine

Godot Engine

Godot Engine logo

2D and 3D cross-platform game engine

Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported in one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms (HTML5) and consoles.

Free, open source and community-driven

Godot is completely free and open source under the very permissive MIT license. No strings attached, no royalties, nothing. The users' games are theirs, down to the last line of engine code. Godot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations. It is supported by the Software Freedom Conservancy not-for-profit.

Before being open sourced in February 2014, Godot had been developed by Juan Linietsky and Ariel Manzur (both still maintaining the project) for several years as an in-house engine, used to publish several work-for-hire titles.

Screenshot of a 3D scene in Godot Engine

Getting the engine

Binary downloads

Official binaries for the Godot editor and the export templates can be found on the homepage.

Compiling from source

See the official docs for compilation instructions for every supported platform.

Community and contributing

Godot is not only an engine but an ever-growing community of users and engine developers. The main community channels are listed on the homepage.

To get in touch with the engine developers, the best way is to join the #godotengine-devel IRC channel on Freenode.

To get started contributing to the project, see the contributing guide.

Documentation and demos

The official documentation is hosted on ReadTheDocs. It is maintained by the Godot community in its own GitHub repository.

The class reference is also accessible from the Godot editor.

The official demos are maintained in their own GitHub repository as well.

There are also a number of other learning resources provided by the community, such as text and video tutorials, demos, etc. Consult the community channels for more information.

Code Triagers Badge Translate on Weblate Total alerts on LGTM TODOs

Owner
Godot Engine
Godot is a popular Free and Open Source game development engine and toolset.
Godot Engine
Comments
  • [TRACKER] Methods, properties and signals to consider for renaming in next planned compatibility breakage

    [TRACKER] Methods, properties and signals to consider for renaming in next planned compatibility breakage

    This issue is meant to keep track of awkwardly named or deprecated methods, properties and signals that we would like to rename next time we have the opportunity.

    This can't be done lightly as it breaks compatibility for users using their old names, so any such change has to be done:

    • either after following a deprecation procedure: marked as deprecated - using it shows a warning - for at least one full minor release cycle (e.g. 3.1.x), then removed in a future minor or major version bump,
    • or within a major compatibility breaking release (such as 3.0 was to 2.1; but such situations won't happen often - if ever again - so the deprecation workflow should be preferred).

    To properly deprecate methods, properties and signals, we need #4397 implemented.

    A :tada: reaction added by @akien-mga or @Calinou means the suggestion in the comment was incorporated into this post.


    Classes

    ~- [ ] OS* could be renamed to Platform* https://github.com/godotengine/godot/issues/16863#issuecomment-403253127~ (See https://github.com/godotengine/godot/pull/47789#issuecomment-854149653) ~- [ ] Label: Consider renaming to TextLabel https://github.com/godotengine/godot/issues/16863#issuecomment-502517425~ (see https://github.com/godotengine/godot/pull/40124#issuecomment-751741421)

    • [x] PHashTranslation should be renamed to ~CompressedTranslation~ OptimizedTranslation (matching its header) PR:#45234
    • [ ] ResourceFormat*: review all classes inheriting ResourceFormatLoader, ResourceFormatSaver and ImageFormatLoader to check that they follow the same naming convention (both class and filename)
    • [x] ShortCut should be renamed to Shortcut https://github.com/godotengine/godot/issues/16863#issuecomment-685236980 #41926
    • [x] TCP_Server and IP_Unix should be renamed to TCPServer and IPUnix PR:#37700
    • [ ] Viewport should be looked over, it is very complex and could likely be simplified https://github.com/godotengine/godot/issues/16863#issuecomment-631789777

    Methods

    • [x] @GDScript (and several other places): instance when used as a verb/action should be instantiate https://github.com/godotengine/godot/issues/16863#issuecomment-367061984 PR:#49693
    • [x] @GDscript: decimals should be renamed to step_decimals #21425
    • [x] @GDscript: stepify should be renamed to snapped for consistency with vectors https://github.com/godotengine/godot/issues/16863#issuecomment-655258916 PR:#44586
    • [x] AcceptDialog and ConfirmationDialog: get_ok and get_cancel should be get_ok_button and get_cancel_button (matching WindowDialog.get_close_button) https://github.com/godotengine/godot/issues/16863#issuecomment-421071469 PR:#44389
    • [ ] AnimatedSprite2D and AnimatedSprite3D: stop should be pause https://github.com/godotengine/godot/issues/31168 PR:#44369
    • [x] Animation: track_remove_key_at_position should be track_remove_key_at_time PR:#44372
    • [ ] AnimationPlayer: play_backwards could be removed https://github.com/godotengine/godot/issues/16863#issuecomment-490298187 PR:#44345
    • [x] Area: set_audio_bus and get_audio_bus should be renamed to set_audio_bus_name and get_audio_bus_name to match the related property and their Area2D counterparts #29670 PR:#44260
    • [ ] Array (some changes also apply to PackedArrays) https://github.com/godotengine/godot/issues/16863#issuecomment-441376010:
      • Rename remove to remove_at (remove by index) to avoid ambiguity
      • Rename erase to remove_value (remove by value) to avoid ambiguity
      • Rename invert to reverse to use more established naming PR:#46991
      • ~Rename duplicate to clone to use more established naming~ (See https://github.com/godotengine/godot/pull/46996#issuecomment-854195903)
      • Rename empty to is_empty to clearly indicate it's a boolean check and not an operation emptying the array PR:#44401
    • [x] Camera: set_znear and set_zfar should be renamed to match the near and far properties https://github.com/godotengine/godot/issues/16863#issuecomment-412810788 PR:#44434
    • [ ] Control: Discrepancy between property names and their setter/getter names https://github.com/godotengine/godot/issues/16863#issuecomment-381420942 PR:#47248
    • [x] CollisionShape: make_convex_from_brothers should be make_convex_from_siblings https://github.com/godotengine/godot/issues/16863#issuecomment-493794313 PR:#41044
    • [x] EditorInterface: get_editor_viewport could be get_editor_main_screen https://github.com/godotengine/godot/issues/16863#issuecomment-634258502 + 2 following comments PR:#44524
    • [x] GridMap: set_cell_item (3 ints) should be replaced by a version with Vector3i #39958
    • [x] InputMap: load_from_globals should be load_from_project_settings https://github.com/godotengine/godot/issues/16863#issuecomment-426457888 PR:#43661
    • [x] ItemList: unselect and unselect_all should be deselect and deselect_all, matching other classes with similar methods. There's also deselect_items in FileDialog, harmonize this #28558 PR:#44569
    • [x] JSON: print should be rename to something else https://github.com/godotengine/godot/issues/16863#issuecomment-557657413 + the following 6 comments PR:~#44574~ #44806
    • [x] KinematicBody and KinematicBody2D: The API grew organically and is becoming quite convoluted, a refactor/reorder of some method arguments might be welcome (see e.g. #16757 #19648).
    • [x] MainLoop: _iteration should be renamed to _physics_process, _idle should be _process. Non virtual methods should be unexposed, and input_text does nothing and should be removed #30096 PR:#44593 ~- [ ] Mesh: surface_get_material -> get_surface_material and surface_set_material -> set_surface_material https://github.com/godotengine/godot/issues/16863#issuecomment-652067884~ See https://github.com/godotengine/godot/issues/16863#issuecomment-747269154
    • [x] Node: get_index and get_position_in_parent are synonyms, one should be removed #21802 #37556
    • [x] Node: is_a_parent_of should be replaced by is_ancestor_of or is_descendant_of https://github.com/godotengine/godot/issues/16863#issuecomment-564532042
    • [x] Node: set_as_toplevel could be set_as_top_level, but its behavior may also need tweaking https://github.com/godotengine/godot/issues/16863#issuecomment-498428024 https://github.com/godotengine/godot/issues/24154 #42451
    • [ ] Node2D and Node3D: Inconsistency with object-local translation code https://github.com/godotengine/godot/issues/16863#issuecomment-530519327 ~- [ ] OptionButton: get_selected_id might be obsolete after #21837~ See https://github.com/godotengine/godot/issues/16863#issuecomment-747413919
    • [x] OS: can_draw would be better suited in the Engine singleton
    • [x] OS: execute should be split in two different methods, one blocking and the other non-blocking. e.g. names: execute/exec_process (blocking) and spawn_process (non-blocking) #19302 PR:#44514
    • [x] Physics (various classes): add_force and apply_impulse methods need harmonization of their arguments order https://github.com/godotengine/godot/issues/16863#issuecomment-416791048 #37350
    • [x] Quat: Consider deprecating set methods https://github.com/godotengine/godot/issues/16863#issuecomment-515892880
    • [x] Rect2: Rename clip to intersection for consistency with AABB. https://github.com/godotengine/godot/issues/16863#issuecomment-655299536 PRs: #44521 #44582
    • [x] RichTextLabel: set_use_bbcode and set_bbcode should be renamed to set_use_fixed_bbcode and set_fixed_bbcode. Warnings should be thrown if bbcode is modified by another function #19118
    • [ ] Skeleton: set_bone_global_pose should be renamed to set_bone_skeleton_pose (same for the getter). get_bone_transform should also be renamed, or dropped if unnecessary #19551
    • [x] Sprite, Sprite3D: set_region and is_region should be renamed to set_region_enabled and is_region_enabled https://github.com/godotengine/godot/issues/16863#issuecomment-380225780 PR:#47001
    • [x] String: ord_at considered unclear, proposal to rename it to unicode_at #15519 PR: #43790
    • [x] String: right behaviour is unintuitive and mostly duplicate of substr https://github.com/godotengine/godot/issues/16863#issuecomment-419635744 PR: ~#47434~ #36180
    • [x] String: Rename http_escape to uri_encode, http_unescape to uri_decode https://github.com/godotengine/godot/issues/16863#issuecomment-503491938 PR:#43978
    • [x] String: Rename empty to is_empty PR: #44401
    • [x] Texture2D: get_data should be get_image https://github.com/godotengine/godot/issues/16863#issuecomment-652064475 PR: #47435
    • [x] TileMap: set_y_sort_mode and is_y_sort_mode_enabled should be renamed to set_y_sort_enabled and is_y_sort_enabled https://github.com/godotengine/godot/issues/16863#issuecomment-380250110 #38635
    • [x] TileMap: Discrepancy between property names and their setter/getter names https://github.com/godotengine/godot/issues/16863#issuecomment-382545668
    • [x] TileMap: set_cell (2 ints) and set_cellv (Vector2) should be replaced by a version with Vector2i #39976
    • [ ] Tree: get_selected should be renamed to something like get_active https://github.com/godotengine/godot/issues/16863#issuecomment-425712040
    • [x] Tween: Many methods return bool for no reason, should be changed to void https://github.com/godotengine/godot/issues/16863#issuecomment-420286639 #36844
    • [x] UndoRedo: is_commiting_action has a typo, should be "committing"
    • [x] VisualServer: sync and draw bindings should be deprecated in favour of the existing force_sync and force_draw #15892
    • [x] Vector2: tangent is considered ambiguous/inaccurate, it should be perpendicular https://github.com/godotengine/godot/issues/16863#issuecomment-618294043 PR: #39685 or #44149
    • [x] XRPositionalTracker: get_type -> get_tracker_type and get_name -> get_tracker_name https://github.com/godotengine/godot/issues/16863#issuecomment-571283702 https://github.com/godotengine/godot/issues/15763#issuecomment-568908661 #36382 https://github.com/godotengine/godot/issues/16863#issuecomment-494437342

    Properties

    • [x] BoxShape, CubeMesh and CSGBox: their dimension properties are inconsistent, and CubeMesh should maybe be renamed to BoxMesh https://github.com/godotengine/godot/issues/16863#issuecomment-403253127 PR:#44091 and #44183
    • [x] Camera2D: offset and offset_h/offset_v are confusingly named as they refer to completely different things. It should likely be harmonized with Camera too which has h_offset and v_offset https://github.com/godotengine/godot/issues/16863#issuecomment-407133383 #7489 PR:#44232
    • [ ] Camera2D: limit_ values could be changed to a Rect2i or similar https://github.com/godotengine/godot/issues/16863#issuecomment-595585595
    • [x] Control: Rename margin to offset now that they can be negative? https://github.com/godotengine/godot/issues/16863#issuecomment-401824810 PR:#44605
    • [x] Control: rect_rotation is in degrees, so it should be renamed to rect_rotation_degrees to match Node2D's rotation_degrees, and a new rect_rotation property should be added which uses radians. PR:#44607 ~- [ ] CPUParticles2D: Rename normalmap to normal_map for consistency https://github.com/godotengine/godot/issues/16863#issuecomment-615254863~ Removed as part of #43052
    • [x] Engine: Rename iterations_per_second to physics_fps to match the project setting of the same name https://github.com/godotengine/godot/issues/16863#issuecomment-554682554 https://github.com/godotengine/godot/pull/41956
    • [ ] ImageTexture: lossy_quality should be changed to an enum (low, mid, high, etc.) instead of a float ratio interpreted as arbitrary plateaus (same in Image::compress()) https://github.com/godotengine/godot/pull/21167#issuecomment-414234160
    • [x] LightOccluder2D: light_mask -> occluder_light_mask https://github.com/godotengine/godot/issues/16863#issuecomment-571283702 https://github.com/godotengine/godot/issues/15763#issuecomment-568908661 https://github.com/godotengine/godot/pull/36382
    • [ ] Label and Button: clip_text is not necessary anymore, as all Controls have rect/clip_content #20228
    • [x] LineEdit: cursor_* properties should be renamed to caret_* #16116 PR:#47448
    • [ ] LineEdit and TextEdit: Their respective APIs could be homogenized as far as possible https://github.com/godotengine/godot/issues/16863#issuecomment-409058538 #20611
    • [x] Node2D, Spatial: inconsistency between position (2D) and translation (3D) #9128 PR:#44198
    • [x] NoiseTexture: Rename as_normalmap to as_normal_map for consistency https://github.com/godotengine/godot/issues/16863#issuecomment-615254863 PR:#44614
    • [x] RayCast: Rename cast_to to target_position https://github.com/godotengine/godot/issues/16863#issuecomment-676512989
    • [ ] RayCast and others: Change disabled properties to enabled ones https://github.com/godotengine/godot/issues/16863#issuecomment-511037393 + the following 2 comments PR:#44141
    • [x] Resource: resource_name is not used, should be dropped #13358
    • [x] TileMap: collision_friction property should be renamed to friction #18191

    Signals

    • [x] CanvasItem: hide should be renamed to hidden PR:#44189
    • [x] Tabs: tab_close and tab_hover should be spelled tab_closed and tab_hovered PR:#44188
    • [ ] Tree: item_activated (label double-click) and item_double_clicked (icon double-click), names don't properly convey what they do #16839: PR:#44185
    • [x] XRController: button_release should be spelled button_released (like button_pressed) PR:#44184

    Enums

    • [x] ArrayMesh: ArrayType enum is a duplicate, delete it https://github.com/godotengine/godot/issues/16863#issuecomment-571283702 https://github.com/godotengine/godot/issues/15763#issuecomment-568908661 https://github.com/godotengine/godot/pull/36382
    • [x] CPUParticles: Flags enum -> ParticleFlags https://github.com/godotengine/godot/issues/16863#issuecomment-571283702 https://github.com/godotengine/godot/issues/15763#issuecomment-568908661 https://github.com/godotengine/godot/pull/36382
    • [x] Mesh: BlendShapeMode enum is only used by ArrayMesh, so give to ArrayMesh https://github.com/godotengine/godot/issues/16863#issuecomment-571283702 https://github.com/godotengine/godot/issues/15763#issuecomment-568908661 https://github.com/godotengine/godot/pull/36382
    • [x] Viewport: ClearMode and UpdateMode enums should use the same suffixes (#19404) PR:#44267
    • [x] XRPositionalTracker: TRACKER_LEFT_HAND -> TRACKER_HAND_LEFT etc https://github.com/godotengine/godot/issues/16863#issuecomment-494437342 PR:#44261
    • [x] Rename the ButtonList enum to MouseButton https://github.com/godotengine/godot/issues/16863#issuecomment-612792875 PR:#38054

    Constants

    • [x] Global Scope: PROPERTY_USAGE_STORE_IF_NONZERO and PROPERTY_USAGE_STORE_IF_NONONE should be fully dropped, also from GDNative #37693

    Theme items

    • [x] ItemList, LineEdit, RichTextLabel, TextEdit and Tree: font_color_selected should be renamed to font_selected_color to match other _color properties. #30018 PR:#44194

    Objects

    • [x] CapsuleShape should be vertical by default #36488

    Shading language

    • [ ] WORLD_MATRIX is actually a model-view matrix and should be renamed. @reduz suggests to replace it (and CAMERA_MATRIX, which is a view matrix) by actual view and model matrices, e.g. CANVAS_MATRIX and ITEM_MATRIX.

    Project settings

    • [ ] display/window/size/test_width and test_height should be renamed to window_width and window_height. We should also consider renaming the width and height settings, maybe render_width and render_height. https://github.com/godotengine/godot/issues/16863#issuecomment-412308210 PR:#47522

    File formats

    • [ ] Discuss what we want to do with custom binary resource extensions (RES_BASE_EXTENSION) https://github.com/godotengine/godot/issues/16863#issuecomment-413620204
  • Typed GDScript

    Typed GDScript

    Alright, big change coming! Let me add a bit of documentation in here.

    FAQ

    Things people asked me during the development.

    • Is it optional?

    Yes. You can use GDScript dynamically as it is now. Type hints can be used only in parts of the code.

    • Will this affect my existing code?

    It shouldn't. If it does then it's a bug. Whenever a type check is possible it will make one, but this won't affect duck-typing. Lines that are fully type-checked are indicated by a highlight in the line number. However, GDScript was very lenient about some behaviors that can be considered an error, so your script might break if it relied on those behaviors.

    • Does it improve performance?

    As it is now: no. However, this enables the possibility of future improvements in performance. A set of benchmarks are needed before we go this path.

    • Can the syntax change to be like <my favorite language>?

    No, this was discussed at length before. The syntax is similar to Python. It's made to be easy to parse without changing the GDScript syntax in itself, considering the types are optional.

    Syntax

    • Variable hint: var my_int : int
      • Optional inline initialization: var my_int : int = 42
      • Type can be omitted to be inferred from value: var my_int : = 42
    • Also for constants (but not strictly needed): const my_const : String = "Something"
    • Function declaration: func (arg1 : int, arg2 : String = "") -> float:
    • Casting: event as InputEventKey
      • It returns null if the cast is not possible.
      • It errors out if trying impossible conversion between built-in types.

    Possible types

    • Built-in variant types (int, float, Vector2, Basis, etc.).
    • Native classes from the ClassDB (Node, Resource, Sprite, AnimationPlayer.
    • Scripts of any kind, they can be preloaded into a constant, then the constant can be used as a type. includes inner classes in other scripts.
    • Named classes in the script server, as added in GDScript with the class_name keyword. Includes their inner classes too.
    • Other classes in the current script (the ones made using the class statement).

    Static checks

    As long as there any type can be fully determined, the parser will try to detect mismatches. This will be shown as an error in the editor.

    • Type mismatch when assigning to a variable.
    • Type mismatch in function arguments when making a call.
    • Missing or exceeding arguments for a function call.
    • Operation in an expression.
      • Whether the operand types are valid for the operator (e.g. can't multiply int and String).
      • What is the resulting type of operation (e.g. 2 * 2 is an int, but 2 * 2.0 is a float).
    • Whether the declared function matches the parent signature.
    • Member variable shadowing one in the same or the parent class.
    • Type mismatch between member variables and setter/getter.
    • Constants and inner classes are in the same scope: if one shadows another they error out.
    • Whether an inner class name shadows a native class from the ClassDB.
    • Non-existing identifier/function.

    Note that since this is meant to be fully optional and still compatible with duck-typing, it won't mark as an error if the member variable/method could be available in a subtype. Instead, type-safe lines will be marked with a subtle green tint in the number line. Non-safe lines will just not be marked:

    Completion

    The code completion was rewritten to make use of the type hints, and also fixed many long-standing bugs. The code is now somewhat cleaner and easier to add new features. Some improvements:

    • Better guessing based on assigned values (Fix #16257, Fix #15088).
    • Guess type of function based on the returned value.
    • Look inner classes too when guessing the type or finding candidates (Fix #1039).
    • Look into other scripts/singletons. (Fix #13951)
    • Use type-hints when they're available.
    • Better definition/documentation lookup

    Wanted feedback

    Any feedback is welcome but there's some things in particular that I want to know. In any case it's great to have sample scripts for me to test.

    • It breaks the current code of your project. This includes parser and compiler errors in general.
    • It doesn't detect a problem when it should.
    • It does detect a problem when it shouldn't.
    • It gives an error in the console saying "Parser bug".
    • It is too slow in a big file or file with lots of dependencies.

    Future

    Before anyone asks, here's a bit of ideas for the future.

    • Add types in signals, including type checks for emit_signal and connect calls.
    • Improve completion inference and better use of type hints.
    • Add warnings (#18271).
    • Homogeneous collections (like var int_array : int[] as an array of integers).
    • Optimizations for better performance.

    Closes #10630.

  • Add a new vector-based default editor theme

    Add a new vector-based default editor theme

    A new, vector-based theme for the editor is required for good-looking hiDPI support. It should probably be drawn using Inkscape and be exportable to PNG with a script, just like the current icons.

    Related issue: UI Concept for Godot

  • Tilemap/draw_rect random flickering with Nvidia drivers

    Tilemap/draw_rect random flickering with Nvidia drivers

    Operating system or device - Godot version: Windows 10, godot3.0alpha1

    Issue description: I made a kinematicbody2D and a tilemap, moving the kinematic body around worked as normal however occasionally one of the tiles on the tilemap would vanish faster than any screen recording software could capture. sometimes 2 would vanish, they would get redrawn however

    Steps to reproduce: Make a tilemap, load some tiles in, make a kinematic body move the body around the game, keep your eyes open, dont blink, watch as some tiles vanish from rendering and quickly come back

  • Bullet physics engine implementation

    Bullet physics engine implementation

    It's long time that we talk about this. and finally today I'm submitting the PR.

    Note

    Before present my job I want highlight some things. This implementation is not intended to completely overwrite the current godot implementation, infact by going to the the project settings is possible choose which Physics engine to use so the developer has 100% freedom about which engine to use (the default is the current Godot physics engine). Godot - physics engine select

    The other thing is that by using bullet physics engine we are not changing nothing about the old usage of Godot. All the old known ways used to handle the physics in the games remains untouched at all. I've made some videos where I compare the two physics engine and the only thing I did to swap the engines was select GodotDefault or Bullet in the settings.

    There are two things to implement vehicle and kinematic character, I'll implement these if this PR will be accepted. The SCsub file must be improved to allow more customization of Bullet.

    Presentation

    Thanks to the good concept of Godot implementation I was able to implement Bullet in a natural way.

    In this video https://www.youtube.com/watch?v=NYLQSaMXHmg I show the areas and the trimeshes that works perfectly, I want to point out that the areas can be used as trigger or space modificator, like is done by default Godot. In this video you can see all the balls that falls down under a limit enter inside a trigger area that destroy it. Another thing is that as you can see Bullet manage better the trimesh collisions and the balls movement.

    In this video https://www.youtube.com/watch?v=4X4GRbmfSnc I want to show you the improvements that Bullet port and for this reason I show three tests. The first test show the joints implementation, So I've made a chain with dynamics number of elements. Using godot physics engine we are limited to 88 elements, but with Bullet we can go further to 300 with 30FPS. The other test I test a slider, hinge, 6DOF + motor joints and with Godot physics it doesn't work at all. The last test I made is usefull to demostrate that Bullet support perfectly the method of godot to create multi shaped bodies

    Conclusion

    As you can see by implementing Bullet physics engine we have the access to a very stable physics engine, that is a lot know and well documented, without losing any performance. We also have the possibility to focus more on the implementation of new featurs like Cloth / soft bodies, or improve performance of trimesh by using vertex reduction utility. And improve the vehicle stability. I've also implemented the heightmap shape so when we'll implement the possibility to create the height field inside the engine the collision shape is ready to work.

    I think this is a good feature and improvement that speed up the implementation of the engine and port even more interest about the third version of this engine, that with the new rendering engine and withy a stable physics engine make this game engine even more competitive. I don't want provide it as a GDNative because I want implement the things that I've pointed above (clothing) that are impossible to support using GDNative since I need to make some changes to engine code.

  • UI Concept for Godot

    UI Concept for Godot

    Hi there,

    This weekend I worked on a conceptual UI for Godot. My focus was on getting a clear and coherent design that can be flexible (fully dockable) and easy to expand in the future, and also up to date with current UX patterns on most 3d related apps. Please take a look and tell me what you think. The concept was first posted on the Godot IRC channel. Thanks to @xodene for the idea of posting the design here.

    gdoto_basic_layout_concept_01

    About the design

    • Font used is Source Sans Pro, an open source font made by Adobe. This font has many weights and alternatives, including an mono spaced version, which suits perfect for scripting.
    • Current icons are from Font Awesome, a set of open source icons well known in web development. My plan is to make a complete set of custom designed icons for Godot, but this could take a lot of time, so for know I sticking with this icon set, just for testing purposes.
    • I took some freedom an added random icons and features, this helps me to see how the layout works.

    Update on Oct 13, 2015 Hi everyone! I finally got time to continue my work on the UI. Here is a quick update on the interface that include some of the features you mentioned on the comments.

    gdoto_ui_concept_02

    I also want to share with you a logo design concept I have been working on in parallel with the UI. This logo is my attempt to a fully coherent and modern Godot visual identity that initially starts with the UI design. Here I tried to simplify the current logo and make it more serious, solid and unique; as well as play well with different sizes and colors.

    gdoto_logotype_concept_01

    As always feel free to let any feedback you want; that's best way to iterate!

  • [TRACKER] More API renames for Godot 4.0

    [TRACKER] More API renames for Godot 4.0

    This is a follow-up to the mega tracker #16863 which we've used for the past 3 years to keep a list of things we'd like to rename in the API for Godot 4.0.

    Many of these renames have been done, some are still pending with open PRs, others might actually not be wanted, as we didn't do thorough discussion of all proposals on that issue.

    Now that we're getting closer to the 4.0 release, it's time to give this a second look, and start anew from the current API.

    Are there more classes, methods, properties, or signals, which have an awkward name and could be improved before we freeze the API to preserve compatibility?

    Here's my workflow proposal for this tracker:

    • Add your suggestions as comments below. Include links to relevant proposals or issues/comments if they exist (but you don't necessarily need to open a proposal for it, unless it's a very substantial change to the API).
    • Upvote the proposals you support, downvotes the ones you disagree with. Don't take downvotes personally, we need to assess the general feeling of the community for a given proposal to see if it makes sense to rename, beyond core maintainers' own intuition.
    • If you're motivated, you can also salvage unresolved suggestions from #16863 so they are considered again here (beware, there are 500 comments...).
    • Suggestions (not approved yet, so don't open PRs for them) will be listed by repo maintainers in the second comment of this issue.
    • Avoid lengthy discussions of suggestions in this tracker, as it makes it hard to keep track of things. Prefer discussion on the Contributor Chat, and if needed, open dedicated proposals for non-consensual suggestions that require more debate.
    • After review, approved suggestions will be moved to the task list below in this first comment, so they can be implemented by contributors and merged.

    Important: This tracker is only for API renames. I.e. changing a name to another name, not changing behavior, adding/removing logic, etc. Anything that changes the behavior of the engine should be discussed in a proposal on https://github.com/godotengine/godot-proposals.

    For this tracker, let's also exclude suggestions for changes in the Project Settings and Editor Settings. Those should probably have their own trackers, as the settings do need a cleanup for 4.0.


    Approved renames

    None yet.

  • Allow exporting custom resources from/to GDScript, VisualScript, C#, and PluginScript.

    Allow exporting custom resources from/to GDScript, VisualScript, C#, and PluginScript.

    Old Content:

    This is a ~~partial~~ complete 4.0 port of #44879. ~~It does not include the GDScript changes from that PR.~~ (Edit: it now exports GDScript resources in the new parser, and as far as I can tell, NativeScript and PluginScript have been rendered moot by GDNative Extensions)

    The changes have been split up into digestible chunks as separate commits. That should hopefully make it easier to review.

    While I've tested it somewhat in 3.2.x, I have not yet had a chance to test this 4.0 port thoroughly.

    I believe the most controversial set of changes for which I have received limited feedback is "Make script class editor UX feel like C++ types." I recall I wrote it in to help address related proposals, but I can't quite recall now which ones they were. Stuff about making named scripted types having a more authentic feel. Anyway, whether that commit is included really needs more community feedback.

    When a final approved version of the PR is ready, I can squash the commits and amend the message.

    Also related is #48056 which has duplicate/similar code changes for some parts of the C# support section from this PR.

    Edit: Sorry about the 3D nodes reviewers. Accidentally included a previous commit in one of my rebased pushes. Please ignore > that.

    I have saved the old history of changes under a new branch called gdres-all-4.0-v1. From this point forward, since this is the PR most people are already "tracking" for solving this issue, I'm going to use it as a staging ground for merging together any relevant PRs that are separately submitted so that others can more easily grab everything significant with which to test out the functionality.

    Child PRs:

    • #62411
    • #62413
    • #62417
    • #63126

    Demo Project (Relies on all of the child PRs being present, which they are in this branch's history): Demo_InspectorResources.zip

    Demo Project for C#/Mono (also relies on all child PRs being present): Demo_InspectorResources_Mono.zip

    Bugsquad edit:

    • Implements and closes https://github.com/godotengine/godot-proposals/issues/18
  • [WIP] Editor Android Port

    [WIP] Editor Android Port

    with the headstart of @fahrstuhl and my stubbornness android port is starting to look like it getting somewhere

    Issue discussing this feature https://github.com/godotengine/godot/issues/267 Proposal for this feature: https://github.com/godotengine/godot-proposals/issues/3931

    currently in wip because

    • [x] Messy code (and hacky code), would like to get comments on it
    • [x] The editor expect double click, which double tap is not (and I"m pretty sure double tap is not in the api)
    • [x] Can't work on master because it's broken for android (or at least to tools build on android, didn't test without tools true) (opend on 3.2 so we can see the actual changes)
    • [x] gradle way to detect normal build vs android studio build so normal build will add no sign to gradle build task and will not build with tools
    • [ ] And more real life testing

    Build instruction https://github.com/godotengine/godot/pull/36776#issuecomment-645644153

    Android Editor apk if you want to test it for yourself (arm64v8)

    EDIT: replaced apk with release_debug version, with directory bug fixed EDIT2: recompiled over newer master commit (5d880bf7db7f46b1509bbe3ed704ea8acbf8e151) EDIT3: uploaded a new version and now link set to build folder where I will upload newer versions instead of editing the link everytime

  • C# as scripting language

    C# as scripting language

    I could not find any other issue mentioning this, so I suppose most discussion about it happened over IRC.

    In #5049 we discussed some things about scripting, and some said the Godot team is considering C#.

    C# is a great language with many features, but I personally think that considering Java 8 is a much better language than Java 6, has a better runtime across many platforms and a better JIT and GC than the CLR (unless things changed in the last year), Java could possibly be a better candidate.

    Unity might use C#, however Godot never set out to be a Unity ripoff. Java is much more popular than C#, according to this site and job postings, and there are many game developers (especially on Android) who use Java.

    Additionally, many of the features that C# offers compared to Java are not much important if the purpose is scripting, as most scripting in games is imperative and (at worst) object-oriented (and many of the advantages C# offers are related to functional programming, which Java 8 supports decently anyway). Just take a look at your average Unity script, even a more complex one like this: there's not much there that can't be done in Java straight away!

    The JVM also offers a good amount of other languages - Kotlin, for examples, which has many features like nullable types, pattern matching and operator overloading. There's also Ceylon, which is in many ways a better C# (and compiles directly to JavaScript). Supporting those would not require any more work than adding a JAR dependency. Java also has a larger amount of libraries.

    And if performance is the main concern and a runtime like the CLR and JVM is too heavy, those can be done away with and C++ could be used directly via LLVM, so that a JIT can be used, avoiding expensive recompilations. This solution is best kept along with GDScript, so that novices (or people who don't need extra performance) can use that instead (and avoid segfaults). The latest standard of C++ has very clean syntax, so I don't think verbosity should be a problem.

    C++ is the solution I would like the best, because it would bring the fastest performance (zero overhead, can't be said for any other language), it would not need any extensive changes (as Godot can already be used from C++, and is written in C++ itself), it would have the more consistent support across platforms and it would make it possible to use Godot for very large projects (such as AAA games - there's a reason most studios use Unreal and not Unity). Additionally, keeping GDScript would let those people who don't need extra performance an easier way to write scripts than Java or C# (both very verbose languages) would be.

    tl;dr: I think C++ (or worse, Java 8) makes a better choice than C# for scripting in Godot.

    Any opinions?

    Edit: I see the "feature proposal" tag (which is correct) but I want to make it clear that I'm not proposing C# support in Godot, I'm merely reporting and commenting on some of the things I've heard around.

  • Heavy stuttering issue in simple 2D game [Windows 10, Nvidia]

    Heavy stuttering issue in simple 2D game [Windows 10, Nvidia]

    Godot version: Godot 3.1-dev / Godot 2.X

    OS/device including version: PC - Windows 10, GeForce GTX 1060 6 GB, 16 GB RAM.

    Issue description: Stuttering / jitters when moving a 2D Sprite. Reproduced on 2 computers (with nvidia graphic cards, the one above and a laptop), a friend of mine reproduce this issue too.

    Steps to reproduce: I just download the "First project" that we can make in the documentation. I have tested to reproduce the first part of this tutorial to only have the player and nothing else. If I run it without change anything. I have some stuttering at the same as the game run with 60 FPS. The motion is not smooth. I collaborate with a dev to try to reproduce this problem and try to understand the issue. I have made a lot of test (Run from editor, run after compilation without debug mode etc...But when I deleted the animation, all run smoothly.

    PS : it seems that physic behaviour make sprite stuttering too (try with kinematic and Area2D node with collision). If I desactivate collision and replace Area2D with a simple node2D there is no stuttering (if I don't play any animation on the player).

    Minimal reproduction project: Here's a minimalist project (that comes from the first game project of the documentation). If I run it, I have some stuttering. If I delete the player animation I have no more stuttering. FirstGame.zip

  • CharacterBody2D giving wrong floor normal when walking across the apex of a CircleShape2D

    CharacterBody2D giving wrong floor normal when walking across the apex of a CircleShape2D

    Godot version

    4.0 beta5 (89a33d28f)

    System information

    Ubuntu 22.04.1

    Issue description

    Examining the return value of get_floor_normal on a CharacterBody2D with the template script for movement, sometimes returns a wrong normal when walking across the apex of a CircleShape2D.

    Steps to reproduce

    Running the scene in the attached project: A CharacterBody2D will drop on a StaticBody2D with a CircleShape2D. When colliding, a pink line will be drawn to indicate the floor normal. The floor normal will be pointing to the side, while a straight up normal is expected. Screenshot from 2022-11-19 22-47-59

    You can jump in place, and sometimes the correct normal will show. You can also walk back and forth around the apex and have brief flashes appear of the incorrect normal.

    Minimal reproduction project

    CollisionNormalTest.zip

  • Fix connection of animation

    Fix connection of animation "changed" signal in AnimationTrackEditor

    Follow up #64647.

    Since the signal connection method was unwillingly changed, there is a bug in the GUI update. This PR fix that.

    Before:

    https://user-images.githubusercontent.com/61938263/202873025-f8182d65-67c4-4c55-9fad-891332bbe407.mp4

    After fix:

    https://user-images.githubusercontent.com/61938263/202873031-f83f89f9-5a19-481f-8fd0-c1e2ddeb4d64.mp4

    Also, the signal "tracks_changed" is almost equivalent to "changed", and there is no reason to exist it separately, so I remove that signal.

  • Godot Editor crash when referencing node in Autoloaded scene script.

    Godot Editor crash when referencing node in Autoloaded scene script.

    Godot version

    v4.0.beta5.official [89a33d28f]

    System information

    Windows 10

    Issue description

    When referencing an @onready node in on a scene script which is autoloaded, the editor crashes.

    Steps to reproduce

    Create an autoloaded Control scene. Add a child Control node. Reference the node via @onready. Access via the GDScript editor the node in a method, and the editor will crash.

    Minimal reproduction project

    reference-test-crash.zip

    In my reproduction project, simply open the "testui.gd", and in the _ready method, attempt to access the "test" control onready var. The editor crashes.

  • Use a modern font stack for system font aliases on Windows, macOS and iOS

    Use a modern font stack for system font aliases on Windows, macOS and iOS

    This closes https://github.com/godotengine/godot-proposals/issues/5767.

    Testing project: test_system_font_alias.zip

    TODO

    • [ ] Test on Windows.
    • [ ] Test on macOS.
    • [ ] Test on iOS.
    • [ ] Rewrite Linux system font alias usage to manually check for known font names, rather than relying on fontconfig for picking a (usually old-looking) font.

    Preview

    Fedora 36 (no change compared to before).

    2022-11-19_21 49 53

  • Debugger - Video RAM window is blank even when running project

    Debugger - Video RAM window is blank even when running project

    Godot version

    4.0 beta 5

    System information

    Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz 3.70 GHz 32.0 GB RAM Nvidia Geforce RTX 2060

    Issue description

    What doesn't work: The entire Video Ram window remains empty during playmode.

    How do you expect it to work instead? There should be a list of files that are in use while the game is playing.

    2022-11-16 19_20_10-street scene - composite tscn - Tales From Off-Peak City RPG - Godot Engine

    Steps to reproduce

    Simply play a project and open the Video RAM tab of the Debugger window to see that it's empty.

    Minimal reproduction project

    N/A (this has happened with every project I've tested)

  • GDScript editor scrolls back to top of the file with an error if double-clicking above certain locations

    GDScript editor scrolls back to top of the file with an error if double-clicking above certain locations

    Godot version

    Godot 4 beta5

    System information

    Windows 10 64 bits NVIDIA GeForce GTX 1060

    Issue description

    The script editor scrolls all the way back up if you double-click in specific locations in text. When that happens, it also logs the following error:

    scene/gui/text_edit.cpp:5140 - Condition "!has_selection(p_caret)" is true. Returning: -1
    

    Steps to reproduce

    With the following script:

    
    extends Node
    
    
    # Called when the node enters the scene tree for the first time.
    func _ready():
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space 
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	# Space
    	var a = ImageTexture.create_from_image(null)
    	pass # Replace with function body.
    
    
    # Called every frame. 'delta' is the elapsed time since the previous frame.
    func _process(delta):
    	pass
    

    Put your mouse over the = sign, then double click a few times.

    Minimal reproduction project

    GDScriptEditorDoubleClickScrollBug.zip

Steam API for the Godot game engine

Steam API for the Godot game engine

Nov 17, 2022
Flax Engine – multi-platform 3D game engine
Flax Engine – multi-platform 3D game engine

Flax Engine – multi-platform 3D game engine

Nov 15, 2022
Godex is a Godot Engine ECS library.

Godex Godex is a Godot Engine ecs library. Disclaimer: this module is still in development, open an issues to report any problem or a new discussion i

Nov 16, 2022
Godot bindings for the Rapier3D physics engine

Godot bindings for the Rapier3D physics library How to use There are two parts: A Godot module which must be compiled with the engine.

Oct 25, 2022
Improved version of the X-Ray Engine, the game engine used in the world-famous S.T.A.L.K.E.R. game series by GSC Game World.
Improved version of the X-Ray Engine, the game engine used in the world-famous S.T.A.L.K.E.R. game series by GSC Game World.

OpenXRay OpenXRay is an improved version of the X-Ray Engine, the game engine used in the world-famous S.T.A.L.K.E.R. game series by GSC Game World. S

Nov 22, 2022
CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine
CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine

CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine. This engine has been designed with a cross-platform design in mind. Thanks to Vulkan API it delivers a next-gen experience with ray tracing to both Linux and Windows platforms

Oct 7, 2022
MAZE (My AmaZing Engine) - 🎮 Personal open-source cross-platform game engine
MAZE (My AmaZing Engine)  - 🎮 Personal open-source cross-platform game engine

MAZE (My AmaZing Engine) is the self-written open-source cross-platform game engine in the active development stage. At the moment it is my main pet project, developed for the purpose of learning and preserving different game dev technologies.

Nov 9, 2022
Ground Engine is an easy to use Game Engine for 3D Game Development written in C++
Ground Engine is an easy to use Game Engine for 3D Game Development written in C++

Ground Engine is an easy to use Game Engine Framework for 3D Game Development written in C++. It's currently under development and its creation will b

Nov 12, 2022
Powerful, mature open-source cross-platform game engine for Python and C++, developed by Disney and CMU
Powerful, mature open-source cross-platform game engine for Python and C++, developed by Disney and CMU

Panda3D Panda3D is a game engine, a framework for 3D rendering and game development for Python and C++ programs. Panda3D is open-source and free for a

Nov 18, 2022
Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve external game process read/write with minimum footprint.
Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve external game process read/write with minimum footprint.

Launcher Abuser Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve ex

Nov 23, 2022
Game Boy, Game Boy Color, and Game Boy Advanced Emulator
Game Boy, Game Boy Color, and Game Boy Advanced Emulator

SkyEmu SkyEmu is low level cycle accurate GameBoy, GameBoy Color and Game Boy Advance emulator that I have been developing in my spare time. Its prima

Nov 22, 2022
Intrinsic is a Vulkan based cross-platform game and rendering engine
Intrinsic is a Vulkan based cross-platform game and rendering engine

Intrinsic is a Vulkan based cross-platform game and rendering engine

Nov 18, 2022
Free, cross-platform 2D game engine powered by Haxe and OpenFL
Free, cross-platform 2D game engine powered by Haxe and OpenFL

flixel | addons | ui | demos | tools | templates | docs | haxeflixel.com Links Here are the most important links to get you started with HaxeFlixel: G

Nov 19, 2022
Minetest is an open source voxel game engine with easy modding and game creation

Minetest is an open source voxel game engine with easy modding and game creation

Nov 15, 2022
Open-source, cross-platform, C++ game engine for creating 2D/3D games.

GamePlay v3.0.0 GamePlay is an open-source, cross-platform, C++ game framework/engine for creating 2D/3D mobile and desktop games. Website Wiki API De

Nov 24, 2022
KlayGE is a cross-platform open source game engine with plugin-based architecture.

KlayGE KlayGE is a cross-platform open source game engine with plugin-based architecture. It's started since 2003. The explicit goal of KlayGE is: to

Nov 24, 2022
A cross-platform 2D game engine

nCine nCine is a cross-platform 2D game engine. It is released under the MIT License, Copyright (c) 2011-2021 Angelo Theodorou. For additional informa

Nov 18, 2022
A powerful free cross-platform RTS game engine

Spring RTS game engine README Spring (formerly TASpring) is an Open Source Real Time Strategy game engine. Visit our project homepage for help, sugges

Nov 22, 2022
CSEngine is a cross-platform 3D game engine.
CSEngine is a cross-platform 3D game engine.

CSEngine - Cross Platform C++ Game Engine CSEngine is a cross-platform 3D game engine. ?? As it is under development, it is not yet suitable for pract

Nov 11, 2022